#define CREDITS_PAGE_ID 1
#define LICENSE_PAGE_ID 2
-#define GTK_ABOUT_DIALOG_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_ABOUT_DIALOG, GtkAboutDialogPrivate))
-
-
enum
{
PROP_0,
static guint signals[LAST_SIGNAL] = { 0 };
-G_DEFINE_TYPE (GtkAboutDialog, gtk_about_dialog, GTK_TYPE_DIALOG)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkAboutDialog, gtk_about_dialog, GTK_TYPE_DIALOG)
static void
gtk_widget_class_bind_callback (widget_class, text_view_key_press_event);
gtk_widget_class_bind_callback (widget_class, text_view_visibility_notify_event);
gtk_widget_class_bind_callback (widget_class, text_view_motion_notify_event);
-
- g_type_class_add_private (object_class, sizeof (GtkAboutDialogPrivate));
}
static gboolean
GtkAboutDialogPrivate *priv;
/* Data */
- priv = GTK_ABOUT_DIALOG_GET_PRIVATE (about);
+ priv = gtk_about_dialog_get_instance_private (about);
about->priv = priv;
priv->name = NULL;
PROP_MODIFIER_MASK,
};
-G_DEFINE_TYPE (GtkAccelGroup, gtk_accel_group, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkAccelGroup, gtk_accel_group, G_TYPE_OBJECT)
/* --- functions --- */
static void
G_TYPE_UINT,
GDK_TYPE_MODIFIER_TYPE,
G_TYPE_CLOSURE);
-
- g_type_class_add_private (object_class, sizeof (GtkAccelGroupPrivate));
}
static void
{
GtkAccelGroupPrivate *priv;
- accel_group->priv = G_TYPE_INSTANCE_GET_PRIVATE (accel_group,
- GTK_TYPE_ACCEL_GROUP,
- GtkAccelGroupPrivate);
+ accel_group->priv = gtk_accel_group_get_instance_private (accel_group);
priv = accel_group->priv;
priv->lock_count = 0;
gint *nat_width);
-G_DEFINE_TYPE (GtkAccelLabel, gtk_accel_label, GTK_TYPE_LABEL)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkAccelLabel, gtk_accel_label, GTK_TYPE_LABEL)
static void
gtk_accel_label_class_init (GtkAccelLabelClass *class)
P_("The widget to be monitored for accelerator changes"),
GTK_TYPE_WIDGET,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (gobject_class, sizeof (GtkAccelLabelPrivate));
}
static void
{
GtkAccelLabelPrivate *priv;
- accel_label->priv = G_TYPE_INSTANCE_GET_PRIVATE (accel_label,
- GTK_TYPE_ACCEL_LABEL,
- GtkAccelLabelPrivate);
+ accel_label->priv = gtk_accel_label_get_instance_private (accel_label);
priv = accel_label->priv;
priv->accel_padding = 3;
static void gtk_accessible_real_connect_widget_destroyed (GtkAccessible *accessible);
-G_DEFINE_TYPE (GtkAccessible, gtk_accessible, ATK_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkAccessible, gtk_accessible, ATK_TYPE_OBJECT)
static void
gtk_accessible_set_property (GObject *object,
static void
gtk_accessible_init (GtkAccessible *accessible)
{
- accessible->priv = G_TYPE_INSTANCE_GET_PRIVATE (accessible,
- GTK_TYPE_ACCESSIBLE,
- GtkAccessiblePrivate);
+ accessible->priv = gtk_accessible_get_instance_private (accessible);
}
static AtkStateSet *
P_("The widget referenced by this accessible."),
GTK_TYPE_WIDGET,
G_PARAM_READWRITE));
-
- g_type_class_add_private (klass, sizeof (GtkAccessiblePrivate));
}
/**
static const gchar* gtk_action_buildable_get_name (GtkBuildable *buildable);
G_DEFINE_TYPE_WITH_CODE (GtkAction, gtk_action, G_TYPE_OBJECT,
+ G_ADD_PRIVATE (GtkAction)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_action_buildable_init))
G_STRUCT_OFFSET (GtkActionClass, activate), NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
- g_type_class_add_private (gobject_class, sizeof (GtkActionPrivate));
}
static void
gtk_action_init (GtkAction *action)
{
- action->private_data = G_TYPE_INSTANCE_GET_PRIVATE (action,
- GTK_TYPE_ACTION,
- GtkActionPrivate);
+ action->private_data = gtk_action_get_instance_private (action);
action->private_data->name = NULL;
action->private_data->label = NULL;
const gchar *tagname,
gpointer *user_data);
-GType
-gtk_action_group_get_type (void)
-{
- static GType type = 0;
-
- if (!type)
- {
- const GTypeInfo type_info =
- {
- sizeof (GtkActionGroupClass),
- NULL, /* base_init */
- NULL, /* base_finalize */
- (GClassInitFunc) gtk_action_group_class_init,
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof (GtkActionGroup),
- 0, /* n_preallocs */
- (GInstanceInitFunc) gtk_action_group_init,
- };
-
- const GInterfaceInfo buildable_info =
- {
- (GInterfaceInitFunc) gtk_action_group_buildable_init,
- NULL,
- NULL
- };
-
- type = g_type_register_static (G_TYPE_OBJECT, I_("GtkActionGroup"),
- &type_info, 0);
-
- g_type_add_interface_static (type,
- GTK_TYPE_BUILDABLE,
- &buildable_info);
- }
- return type;
-}
-
-static GObjectClass *parent_class = NULL;
static guint action_group_signals[LAST_SIGNAL] = { 0 };
+G_DEFINE_TYPE_WITH_CODE (GtkActionGroup, gtk_action_group, G_TYPE_OBJECT,
+ G_ADD_PRIVATE (GtkActionGroup)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
+ gtk_action_group_buildable_init))
+
static void
gtk_action_group_class_init (GtkActionGroupClass *klass)
{
GObjectClass *gobject_class;
gobject_class = G_OBJECT_CLASS (klass);
- parent_class = g_type_class_peek_parent (klass);
gobject_class->finalize = gtk_action_group_finalize;
gobject_class->set_property = gtk_action_group_set_property;
_gtk_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
GTK_TYPE_ACTION);
-
- g_type_class_add_private (gobject_class, sizeof (GtkActionGroupPrivate));
}
static void
gtk_action_group_init (GtkActionGroup *action_group)
{
- GtkActionGroupPrivate *private;
-
- action_group->priv = G_TYPE_INSTANCE_GET_PRIVATE (action_group,
- GTK_TYPE_ACTION_GROUP,
- GtkActionGroupPrivate);
- private = action_group->priv;
-
- private->name = NULL;
- private->sensitive = TRUE;
- private->visible = TRUE;
- private->actions = g_hash_table_new_full (g_str_hash, g_str_equal,
- NULL,
- (GDestroyNotify) remove_action);
- private->translate_func = NULL;
- private->translate_data = NULL;
- private->translate_notify = NULL;
+ action_group->priv = gtk_action_group_get_instance_private (action_group);
+ action_group->priv->name = NULL;
+ action_group->priv->sensitive = TRUE;
+ action_group->priv->visible = TRUE;
+ action_group->priv->actions = g_hash_table_new_full (g_str_hash, g_str_equal,
+ NULL,
+ (GDestroyNotify) remove_action);
+ action_group->priv->translate_func = NULL;
+ action_group->priv->translate_data = NULL;
+ action_group->priv->translate_notify = NULL;
}
static void
static void
gtk_action_group_finalize (GObject *object)
{
- GtkActionGroup *self;
- GtkActionGroupPrivate *private;
-
- self = GTK_ACTION_GROUP (object);
- private = self->priv;
+ GtkActionGroup *self = GTK_ACTION_GROUP (object);
- g_free (private->name);
- private->name = NULL;
+ g_free (self->priv->name);
- g_hash_table_destroy (private->actions);
- private->actions = NULL;
+ g_hash_table_destroy (self->priv->actions);
- g_clear_object (&private->accel_group);
+ g_clear_object (&self->priv->accel_group);
- if (private->translate_notify)
- private->translate_notify (private->translate_data);
+ if (self->priv->translate_notify != NULL)
+ self->priv->translate_notify (self->priv->translate_data);
- parent_class->finalize (object);
+ G_OBJECT_CLASS (gtk_action_group_parent_class)->finalize (object);
}
static void
static guint64 adjustment_changed_stamp = 0; /* protected by global gdk lock */
-G_DEFINE_TYPE (GtkAdjustment, gtk_adjustment, G_TYPE_INITIALLY_UNOWNED)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkAdjustment, gtk_adjustment, G_TYPE_INITIALLY_UNOWNED)
static void
gtk_adjustment_class_init (GtkAdjustmentClass *class)
NULL, NULL,
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
- g_type_class_add_private (class, sizeof (GtkAdjustmentPrivate));
}
static void
gtk_adjustment_init (GtkAdjustment *adjustment)
{
- adjustment->priv = G_TYPE_INSTANCE_GET_PRIVATE (adjustment,
- GTK_TYPE_ADJUSTMENT,
- GtkAdjustmentPrivate);
+ adjustment->priv = gtk_adjustment_get_instance_private (adjustment);
}
static void
gint *minimum_baseline,
gint *natural_baseline);
-G_DEFINE_TYPE (GtkAlignment, gtk_alignment, GTK_TYPE_BIN)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkAlignment, gtk_alignment, GTK_TYPE_BIN)
static void
gtk_alignment_class_init (GtkAlignmentClass *class)
G_MAXINT,
0,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (gobject_class, sizeof (GtkAlignmentPrivate));
}
static void
{
GtkAlignmentPrivate *priv;
- alignment->priv = G_TYPE_INSTANCE_GET_PRIVATE (alignment,
- GTK_TYPE_ALIGNMENT,
- GtkAlignmentPrivate);
+ alignment->priv = gtk_alignment_get_instance_private (alignment);
priv = alignment->priv;
gtk_widget_set_has_window (GTK_WIDGET (alignment), FALSE);
static guint signals[NUM_SIGNALS] = { 0, };
-G_DEFINE_TYPE_WITH_CODE (GtkAppChooserButton, gtk_app_chooser_button, GTK_TYPE_COMBO_BOX,
- G_IMPLEMENT_INTERFACE (GTK_TYPE_APP_CHOOSER,
- app_chooser_iface_init));
-
struct _GtkAppChooserButtonPrivate {
GtkListStore *store;
GHashTable *custom_item_names;
};
+G_DEFINE_TYPE_WITH_CODE (GtkAppChooserButton, gtk_app_chooser_button, GTK_TYPE_COMBO_BOX,
+ G_ADD_PRIVATE (GtkAppChooserButton)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_APP_CHOOSER,
+ app_chooser_iface_init));
+
static gboolean
row_separator_func (GtkTreeModel *model,
GtkTreeIter *iter,
_gtk_marshal_VOID__STRING,
G_TYPE_NONE,
1, G_TYPE_STRING);
-
- g_type_class_add_private (klass, sizeof (GtkAppChooserButtonPrivate));
}
static void
gtk_app_chooser_button_init (GtkAppChooserButton *self)
{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GTK_TYPE_APP_CHOOSER_BUTTON,
- GtkAppChooserButtonPrivate);
+ self->priv = gtk_app_chooser_button_get_instance_private (self);
self->priv->custom_item_names =
g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, NULL);
static void gtk_app_chooser_dialog_iface_init (GtkAppChooserIface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkAppChooserDialog, gtk_app_chooser_dialog, GTK_TYPE_DIALOG,
+ G_ADD_PRIVATE (GtkAppChooserDialog)
G_IMPLEMENT_INTERFACE (GTK_TYPE_APP_CHOOSER,
gtk_app_chooser_dialog_iface_init));
gtk_widget_class_bind_child (widget_class, GtkAppChooserDialogPrivate, show_more_button);
gtk_widget_class_bind_child (widget_class, GtkAppChooserDialogPrivate, inner_box);
gtk_widget_class_bind_callback (widget_class, show_more_button_clicked_cb);
-
- g_type_class_add_private (klass, sizeof (GtkAppChooserDialogPrivate));
}
static void
gtk_app_chooser_dialog_init (GtkAppChooserDialog *self)
{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GTK_TYPE_APP_CHOOSER_DIALOG,
- GtkAppChooserDialogPrivate);
+ self->priv = gtk_app_chooser_dialog_get_instance_private (self);
gtk_widget_init_template (GTK_WIDGET (self));
static void app_chooser_online_iface_init (GtkAppChooserOnlineInterface *iface);
static void app_chooser_online_pk_async_initable_init (GAsyncInitableIface *iface);
+struct _GtkAppChooserOnlinePkPrivate {
+ GSimpleAsyncResult *init_result;
+ guint watch_id;
+
+ GDBusProxy *proxy;
+ GSimpleAsyncResult *result;
+ GtkWindow *parent;
+};
+
G_DEFINE_TYPE_WITH_CODE (GtkAppChooserOnlinePk, gtk_app_chooser_online_pk,
G_TYPE_OBJECT,
+ G_ADD_PRIVATE (GtkAppChooserOnlinePk)
G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_INITABLE,
app_chooser_online_pk_async_initable_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_APP_CHOOSER_ONLINE,
g_define_type_id,
"packagekit", 10));
-struct _GtkAppChooserOnlinePkPrivate {
- GSimpleAsyncResult *init_result;
- guint watch_id;
-
- GDBusProxy *proxy;
- GSimpleAsyncResult *result;
- GtkWindow *parent;
-};
-
static void
gtk_app_chooser_online_pk_dispose (GObject *obj)
{
GObjectClass *oclass = G_OBJECT_CLASS (klass);
oclass->dispose = gtk_app_chooser_online_pk_dispose;
-
- g_type_class_add_private (klass, sizeof (GtkAppChooserOnlinePkPrivate));
}
static void
gtk_app_chooser_online_pk_init (GtkAppChooserOnlinePk *self)
{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GTK_TYPE_APP_CHOOSER_ONLINE_PK,
- GtkAppChooserOnlinePkPrivate);
+ self->priv = gtk_app_chooser_online_pk_get_instance_private (self);
}
static gboolean
static void gtk_app_chooser_widget_iface_init (GtkAppChooserIface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkAppChooserWidget, gtk_app_chooser_widget, GTK_TYPE_BOX,
+ G_ADD_PRIVATE (GtkAppChooserWidget)
G_IMPLEMENT_INTERFACE (GTK_TYPE_APP_CHOOSER,
gtk_app_chooser_widget_iface_init));
gtk_widget_class_bind_callback (widget_class, refresh_and_emit_app_selected);
gtk_widget_class_bind_callback (widget_class, program_list_selection_activated);
gtk_widget_class_bind_callback (widget_class, widget_button_press_event_cb);
-
- g_type_class_add_private (klass, sizeof (GtkAppChooserWidgetPrivate));
}
static void
GtkTreeSelection *selection;
GtkTreeModel *sort;
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GTK_TYPE_APP_CHOOSER_WIDGET,
- GtkAppChooserWidgetPrivate);
+ self->priv = gtk_app_chooser_widget_get_instance_private (self);
gtk_widget_init_template (GTK_WIDGET (self));
PROP_ACTIVE_WINDOW
};
-G_DEFINE_TYPE (GtkApplication, gtk_application, G_TYPE_APPLICATION)
-
struct _GtkApplicationPrivate
{
GList *windows;
#endif
};
+G_DEFINE_TYPE_WITH_PRIVATE (GtkApplication, gtk_application, G_TYPE_APPLICATION)
+
#ifdef GDK_WINDOWING_X11
static void
gtk_application_x11_publish_menu (GtkApplication *application,
static void
gtk_application_init (GtkApplication *application)
{
- application->priv = G_TYPE_INSTANCE_GET_PRIVATE (application,
- GTK_TYPE_APPLICATION,
- GtkApplicationPrivate);
+ application->priv = gtk_application_get_instance_private (application);
#ifdef GDK_WINDOWING_X11
application->priv->next_id = 1;
class->window_added = gtk_application_window_added;
class->window_removed = gtk_application_window_removed;
- g_type_class_add_private (class, sizeof (GtkApplicationPrivate));
-
/**
* GtkApplication::window-added:
* @application: the #GtkApplication which emitted the signal
}
G_DEFINE_TYPE_WITH_CODE (GtkApplicationWindow, gtk_application_window, GTK_TYPE_WINDOW,
+ G_ADD_PRIVATE (GtkApplicationWindow)
G_IMPLEMENT_INTERFACE (G_TYPE_ACTION_GROUP, gtk_application_window_group_iface_init)
G_IMPLEMENT_INTERFACE (G_TYPE_ACTION_MAP, gtk_application_window_map_iface_init))
static void
gtk_application_window_init (GtkApplicationWindow *window)
{
- window->priv = G_TYPE_INSTANCE_GET_PRIVATE (window, GTK_TYPE_APPLICATION_WINDOW, GtkApplicationWindowPrivate);
+ window->priv = gtk_application_window_get_instance_private (window);
window->priv->actions = gtk_application_window_actions_new (window);
window->priv->app_menu_section = g_menu_new ();
"menubar at the top of the window"),
TRUE, G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
g_object_class_install_properties (object_class, N_PROPS, gtk_application_window_properties);
- g_type_class_add_private (class, sizeof (GtkApplicationWindowPrivate));
}
/**
gint *minimum_size,
gint *natural_size);
-G_DEFINE_TYPE (GtkArrow, gtk_arrow, GTK_TYPE_MISC)
-
+G_DEFINE_TYPE_WITH_PRIVATE (GtkArrow, gtk_arrow, GTK_TYPE_MISC)
static void
gtk_arrow_class_init (GtkArrowClass *class)
0.0, 1.0, 0.7,
GTK_PARAM_READABLE));
- g_type_class_add_private (class, sizeof (GtkArrowPrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_ARROW_ACCESSIBLE);
}
static void
gtk_arrow_init (GtkArrow *arrow)
{
- GtkArrowPrivate *priv;
-
- arrow->priv = G_TYPE_INSTANCE_GET_PRIVATE (arrow,
- GTK_TYPE_ARROW,
- GtkArrowPrivate);
- priv = arrow->priv;
+ arrow->priv = gtk_arrow_get_instance_private (arrow);
gtk_widget_set_has_window (GTK_WIDGET (arrow), FALSE);
- priv->arrow_type = GTK_ARROW_RIGHT;
- priv->shadow_type = GTK_SHADOW_OUT;
+ arrow->priv->arrow_type = GTK_ARROW_RIGHT;
+ arrow->priv->shadow_type = GTK_SHADOW_OUT;
}
static void
#define MAX_RATIO 10000.0
#define MIN_RATIO 0.0001
-G_DEFINE_TYPE (GtkAspectFrame, gtk_aspect_frame, GTK_TYPE_FRAME)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkAspectFrame, gtk_aspect_frame, GTK_TYPE_FRAME)
static void
gtk_aspect_frame_class_init (GtkAspectFrameClass *class)
P_("Force aspect ratio to match that of the frame's child"),
TRUE,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (class, sizeof (GtkAspectFramePrivate));
}
static void
gtk_aspect_frame_init (GtkAspectFrame *aspect_frame)
{
- GtkAspectFramePrivate *priv;
-
- aspect_frame->priv = G_TYPE_INSTANCE_GET_PRIVATE (aspect_frame,
- GTK_TYPE_ASPECT_FRAME,
- GtkAspectFramePrivate);
- priv = aspect_frame->priv;
+ aspect_frame->priv = gtk_aspect_frame_get_instance_private (aspect_frame);
- priv->xalign = 0.5;
- priv->yalign = 0.5;
- priv->ratio = 1.0;
- priv->obey_child = TRUE;
+ aspect_frame->priv->xalign = 0.5;
+ aspect_frame->priv->yalign = 0.5;
+ aspect_frame->priv->ratio = 1.0;
+ aspect_frame->priv->obey_child = TRUE;
}
static void
G_DEFINE_TYPE_WITH_CODE (GtkAssistant, gtk_assistant, GTK_TYPE_WINDOW,
+ G_ADD_PRIVATE (GtkAssistant)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_assistant_buildable_interface_init))
gtk_widget_class_bind_callback (widget_class, on_assistant_back);
gtk_widget_class_bind_callback (widget_class, on_assistant_cancel);
gtk_widget_class_bind_callback (widget_class, on_assistant_last);
-
- g_type_class_add_private (gobject_class, sizeof (GtkAssistantPrivate));
}
static gint
{
GtkAssistantPrivate *priv;
- assistant->priv = G_TYPE_INSTANCE_GET_PRIVATE (assistant,
- GTK_TYPE_ASSISTANT,
- GtkAssistantPrivate);
+ assistant->priv = gtk_assistant_get_instance_private (assistant);
+
priv = assistant->priv;
priv->pages = NULL;
priv->current_page = NULL;
#define DEFAULT_CHILD_IPAD_Y 0
#define DEFAULT_LAYOUT_STYLE GTK_BUTTONBOX_EDGE
-G_DEFINE_TYPE (GtkButtonBox, gtk_button_box, GTK_TYPE_BOX)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkButtonBox, gtk_button_box, GTK_TYPE_BOX)
static void
gtk_button_box_class_init (GtkButtonBoxClass *class)
P_("If TRUE, the child will not be subject to homogeneous sizing"),
FALSE,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (class, sizeof (GtkButtonBoxPrivate));
}
static void
gtk_button_box_init (GtkButtonBox *button_box)
{
- GtkButtonBoxPrivate *priv;
-
- button_box->priv = G_TYPE_INSTANCE_GET_PRIVATE (button_box,
- GTK_TYPE_BUTTON_BOX,
- GtkButtonBoxPrivate);
- priv = button_box->priv;
+ button_box->priv = gtk_button_box_get_instance_private (button_box);
+ button_box->priv->layout_style = DEFAULT_LAYOUT_STYLE;
gtk_box_set_spacing (GTK_BOX (button_box), 0);
- priv->layout_style = DEFAULT_LAYOUT_STYLE;
}
static void
static void gtk_bin_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
-G_DEFINE_ABSTRACT_TYPE (GtkBin, gtk_bin, GTK_TYPE_CONTAINER)
+G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GtkBin, gtk_bin, GTK_TYPE_CONTAINER)
static void
gtk_bin_class_init (GtkBinClass *class)
container_class->remove = gtk_bin_remove;
container_class->forall = gtk_bin_forall;
container_class->child_type = gtk_bin_child_type;
-
- g_type_class_add_private (class, sizeof (GtkBinPrivate));
}
static void
gtk_bin_init (GtkBin *bin)
{
- GtkBinPrivate *priv;
-
- bin->priv = G_TYPE_INSTANCE_GET_PRIVATE (bin,
- GTK_TYPE_BIN,
- GtkBinPrivate);
- priv = bin->priv;
+ bin->priv = gtk_bin_get_instance_private (bin);
gtk_widget_set_has_window (GTK_WIDGET (bin), FALSE);
-
- priv->child = NULL;
}
G_DEFINE_TYPE_WITH_CODE (GtkBox, gtk_box, GTK_TYPE_CONTAINER,
- G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE,
- NULL))
+ G_ADD_PRIVATE (GtkBox)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL))
static void
gtk_box_class_init (GtkBoxClass *class)
-1, G_MAXINT, 0,
GTK_PARAM_READWRITE));
- g_type_class_add_private (object_class, sizeof (GtkBoxPrivate));
-
gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_FILLER);
}
{
GtkBoxPrivate *private;
- box->priv = G_TYPE_INSTANCE_GET_PRIVATE (box,
- GTK_TYPE_BOX,
- GtkBoxPrivate);
+ box->priv = gtk_box_get_instance_private (box);
private = box->priv;
gtk_widget_set_has_window (GTK_WIDGET (box), FALSE);
guint final_position : 2;
};
-G_DEFINE_TYPE (GtkBubbleWindow, _gtk_bubble_window, GTK_TYPE_WINDOW)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkBubbleWindow, _gtk_bubble_window, GTK_TYPE_WINDOW)
static void
_gtk_bubble_window_init (GtkBubbleWindow *window)
GdkVisual *visual;
widget = GTK_WIDGET (window);
- window->priv = G_TYPE_INSTANCE_GET_PRIVATE (window,
- GTK_TYPE_BUBBLE_WINDOW,
- GtkBubbleWindowPrivate);
+ window->priv = _gtk_bubble_window_get_instance_private (window);
gtk_window_set_default_size (GTK_WINDOW (window),
TAIL_GAP_WIDTH, TAIL_GAP_WIDTH);
gtk_widget_set_app_paintable (widget, TRUE);
P_("Position to place the bubble window"),
GTK_TYPE_POSITION_TYPE, GTK_POS_TOP,
GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
-
- g_type_class_add_private (klass, sizeof (GtkBubbleWindowPrivate));
}
static void
GType template_type;
};
-G_DEFINE_TYPE (GtkBuilder, gtk_builder, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkBuilder, gtk_builder, G_TYPE_OBJECT)
static void
gtk_builder_class_init (GtkBuilderClass *klass)
P_("The translation domain used by gettext"),
NULL,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (gobject_class, sizeof (GtkBuilderPrivate));
}
static void
gtk_builder_init (GtkBuilder *builder)
{
- builder->priv = G_TYPE_INSTANCE_GET_PRIVATE (builder, GTK_TYPE_BUILDER,
- GtkBuilderPrivate);
+ builder->priv = gtk_builder_get_instance_private (builder);
builder->priv->domain = NULL;
builder->priv->objects = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, g_object_unref);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
G_DEFINE_TYPE_WITH_CODE (GtkButton, gtk_button, GTK_TYPE_BIN,
+ G_ADD_PRIVATE (GtkButton)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIONABLE, gtk_button_actionable_iface_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,
gtk_button_activatable_interface_init))
2,
GTK_PARAM_READABLE));
- g_type_class_add_private (gobject_class, sizeof (GtkButtonPrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_BUTTON_ACCESSIBLE);
}
GtkButtonPrivate *priv;
GtkStyleContext *context;
- button->priv = G_TYPE_INSTANCE_GET_PRIVATE (button,
- GTK_TYPE_BUTTON,
- GtkButtonPrivate);
+ button->priv = gtk_button_get_instance_private (button);
priv = button->priv;
gtk_widget_set_can_focus (GTK_WIDGET (button), TRUE);
gint detail_overflow[6];
};
-#define GTK_CALENDAR_GET_PRIVATE(widget) (GTK_CALENDAR (widget)->priv)
-
static void gtk_calendar_finalize (GObject *calendar);
static void gtk_calendar_destroy (GtkWidget *widget);
static void gtk_calendar_set_property (GObject *object,
static char *default_abbreviated_dayname[7];
static char *default_monthname[12];
-G_DEFINE_TYPE (GtkCalendar, gtk_calendar, GTK_TYPE_WIDGET)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkCalendar, gtk_calendar, GTK_TYPE_WIDGET)
static void
gtk_calendar_class_init (GtkCalendarClass *class)
NULL, NULL,
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
- g_type_class_add_private (gobject_class, sizeof (GtkCalendarPrivate));
}
static void
gchar *week_start;
#endif
- priv = calendar->priv = G_TYPE_INSTANCE_GET_PRIVATE (calendar,
- GTK_TYPE_CALENDAR,
- GtkCalendarPrivate);
+ priv = calendar->priv = gtk_calendar_get_instance_private (calendar);
gtk_widget_set_can_focus (widget, TRUE);
gtk_widget_set_has_window (widget, FALSE);
static void
calendar_queue_refresh (GtkCalendar *calendar)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
if (!(priv->detail_func) ||
!(priv->display_flags & GTK_CALENDAR_SHOW_DETAILS) ||
{
GtkCalendarPrivate *priv = calendar->priv;
- return (GTK_CALENDAR_GET_PRIVATE (calendar)->main_h - CALENDAR_MARGIN
+ return (priv->main_h - CALENDAR_MARGIN
- ((priv->display_flags & GTK_CALENDAR_SHOW_DAY_NAMES)
? calendar_get_ysep (calendar) : CALENDAR_MARGIN)) / 6;
}
week_width = 0;
}
- width = GTK_CALENDAR_GET_PRIVATE (calendar)->day_width;
+ width = calendar->priv->day_width;
if (priv->display_flags & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
x_left = week_width + calendar_xsep + (width + DAY_XSEP) * column;
else
for (c = 0; c < 7; c++)
{
x_left = calendar_left_x_for_column (calendar, c);
- x_right = x_left + GTK_CALENDAR_GET_PRIVATE (calendar)->day_width;
+ x_right = x_left + calendar->priv->day_width;
if (event_x >= x_left && event_x < x_right)
{
GdkRectangle *rect)
{
GtkWidget *widget = GTK_WIDGET (calendar);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
GtkAllocation allocation;
GtkStyleContext *context;
GtkStateFlags state;
gint col,
GdkRectangle *rect)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
rect->x = calendar_left_x_for_column (calendar, col);
rect->y = calendar_top_y_for_row (calendar, row);
static void
gtk_calendar_destroy (GtkWidget *widget)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = GTK_CALENDAR (widget)->priv;
calendar_stop_spinning (GTK_CALENDAR (widget));
calendar_realize_arrows (GtkCalendar *calendar)
{
GtkWidget *widget = GTK_WIDGET (calendar);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
GdkWindowAttr attributes;
gint attributes_mask;
gint i;
static void
calendar_unrealize_arrows (GtkCalendar *calendar)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
gint i;
for (i = 0; i < 4; i++)
static void
gtk_calendar_realize (GtkWidget *widget)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = GTK_CALENDAR (widget)->priv;
GdkWindowAttr attributes;
gint attributes_mask;
gint inner_border = calendar_get_inner_border (GTK_CALENDAR (widget));
static void
gtk_calendar_unrealize (GtkWidget *widget)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = GTK_CALENDAR (widget)->priv;
calendar_unrealize_arrows (GTK_CALENDAR (widget));
static void
calendar_map_arrows (GtkCalendar *calendar)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
gint i;
for (i = 0; i < 4; i++)
static void
calendar_unmap_arrows (GtkCalendar *calendar)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
gint i;
for (i = 0; i < 4; i++)
static void
gtk_calendar_map (GtkWidget *widget)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = GTK_CALENDAR (widget)->priv;
GTK_WIDGET_CLASS (gtk_calendar_parent_class)->map (widget);
static void
gtk_calendar_unmap (GtkWidget *widget)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = GTK_CALENDAR (widget)->priv;
calendar_unmap_arrows (GTK_CALENDAR (widget));
gint row,
gint column)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = GTK_CALENDAR (calendar)->priv;
gint year, month;
if (priv->detail_func == NULL)
gboolean keyboard_mode,
GtkTooltip *tooltip)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
GtkCalendar *calendar = GTK_CALENDAR (widget);
+ GtkCalendarPrivate *priv = calendar->priv;
gchar *detail = NULL;
GdkRectangle day_rect;
gint row, col;
GtkRequisition *requisition)
{
GtkCalendar *calendar = GTK_CALENDAR (widget);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = calendar->priv;
GtkStyleContext *context;
GtkStateFlags state;
GtkBorder padding;
GtkAllocation *allocation)
{
GtkCalendar *calendar = GTK_CALENDAR (widget);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = calendar->priv;
GtkStyleContext *context;
GtkStateFlags state;
GtkBorder padding;
calendar_paint_header (GtkCalendar *calendar, cairo_t *cr)
{
GtkWidget *widget = GTK_WIDGET (calendar);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
GtkAllocation allocation;
GtkStyleContext *context;
GtkStateFlags state;
cairo_t *cr)
{
GtkWidget *widget = GTK_WIDGET (calendar);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
GtkStyleContext *context;
GtkStateFlags state;
GtkBorder padding;
cairo_t *cr)
{
GtkWidget *widget = GTK_WIDGET (calendar);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
GtkStyleContext *context;
GtkStateFlags state;
GtkBorder padding;
gint col)
{
GtkWidget *widget = GTK_WIDGET (calendar);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
GtkStyleContext *context;
GtkStateFlags state = 0;
gchar *detail;
calendar_invalidate_arrow (GtkCalendar *calendar,
guint arrow)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
if (priv->display_flags & GTK_CALENDAR_SHOW_HEADING &&
priv->arrow_win[arrow])
guint arrow)
{
GtkWidget *widget = GTK_WIDGET (calendar);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = calendar->priv;
GtkStyleContext *context;
GtkStateFlags state;
GdkRectangle rect;
cairo_t *cr)
{
GtkCalendar *calendar = GTK_CALENDAR (widget);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = calendar->priv;
int i;
if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)))
calendar_timer (gpointer data)
{
GtkCalendar *calendar = data;
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
gboolean retval = FALSE;
if (priv->timer)
calendar_start_spinning (GtkCalendar *calendar,
gint click_child)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
priv->click_child = click_child;
static void
calendar_stop_spinning (GtkCalendar *calendar)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
if (priv->timer)
{
GdkEventButton *event)
{
GtkWidget *widget = GTK_WIDGET (calendar);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
gint x, y;
gint win_x, win_y;
gint row, col;
GdkEventButton *event)
{
GtkCalendar *calendar = GTK_CALENDAR (widget);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = calendar->priv;
gint arrow = -1;
if (event->window == priv->main_win)
GdkEventButton *event)
{
GtkCalendar *calendar = GTK_CALENDAR (widget);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = calendar->priv;
if (event->button == GDK_BUTTON_PRIMARY)
{
gtk_calendar_motion_notify (GtkWidget *widget,
GdkEventMotion *event)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = GTK_CALENDAR (widget)->priv;
if (priv->in_drag)
{
GdkEventCrossing *event)
{
GtkCalendar *calendar = GTK_CALENDAR (widget);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = calendar->priv;
if (event->window == priv->arrow_win[ARROW_MONTH_LEFT])
{
GdkEventCrossing *event)
{
GtkCalendar *calendar = GTK_CALENDAR (widget);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = calendar->priv;
if (event->window == priv->arrow_win[ARROW_MONTH_LEFT])
{
GtkStateFlags previous_state)
{
GtkCalendar *calendar = GTK_CALENDAR (widget);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = calendar->priv;
if (!gtk_widget_is_sensitive (widget))
{
gtk_calendar_focus_out (GtkWidget *widget,
GdkEventFocus *event)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
GtkCalendar *calendar = GTK_CALENDAR (widget);
calendar_queue_refresh (calendar);
calendar_stop_spinning (calendar);
- priv->in_drag = 0;
+ calendar->priv->in_drag = 0;
return FALSE;
}
GdkDragContext *context,
guint time)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = GTK_CALENDAR (widget)->priv;
priv->drag_highlight = 0;
gtk_drag_unhighlight (widget);
gint y,
guint time)
{
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
+ GtkCalendarPrivate *priv = GTK_CALENDAR (widget)->priv;
GdkAtom target;
if (!priv->drag_highlight)
GtkCalendarDisplayOptions flags)
{
GtkWidget *widget = GTK_WIDGET (calendar);
- GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ GtkCalendarPrivate *priv = calendar->priv;
gint resize = 0;
GtkCalendarDisplayOptions old_flags;
g_return_if_fail (GTK_IS_CALENDAR (calendar));
- priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ priv = calendar->priv;
if (priv->detail_func_destroy)
priv->detail_func_destroy (priv->detail_func_user_data);
g_return_if_fail (GTK_IS_CALENDAR (calendar));
- priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ priv = calendar->priv;
if (chars != priv->detail_width_chars)
{
g_return_if_fail (GTK_IS_CALENDAR (calendar));
- priv = GTK_CALENDAR_GET_PRIVATE (calendar);
+ priv = calendar->priv;
if (rows != priv->detail_height_rows)
{
gtk_calendar_get_detail_width_chars (GtkCalendar *calendar)
{
g_return_val_if_fail (GTK_IS_CALENDAR (calendar), 0);
- return GTK_CALENDAR_GET_PRIVATE (calendar)->detail_width_chars;
+
+ return calendar->priv->detail_width_chars;
}
/**
gtk_calendar_get_detail_height_rows (GtkCalendar *calendar)
{
g_return_val_if_fail (GTK_IS_CALENDAR (calendar), 0);
- return GTK_CALENDAR_GET_PRIVATE (calendar)->detail_height_rows;
+
+ return calendar->priv->detail_height_rows;
}
#define PARAM_SPEC_SET_PARAM_ID(pspec, id) ((pspec)->param_id = (id))
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GtkCellArea, gtk_cell_area, G_TYPE_INITIALLY_UNOWNED,
+ G_ADD_PRIVATE (GtkCellArea)
G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
gtk_cell_area_cell_layout_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
{
GtkCellAreaPrivate *priv;
- area->priv = G_TYPE_INSTANCE_GET_PRIVATE (area,
- GTK_TYPE_CELL_AREA,
- GtkCellAreaPrivate);
+ area->priv = gtk_cell_area_get_instance_private (area);
priv = area->priv;
priv->cell_info = g_hash_table_new_full (g_direct_hash,
/* Pool for Cell Properties */
if (!cell_property_pool)
cell_property_pool = g_param_spec_pool_new (FALSE);
-
- g_type_class_add_private (object_class, sizeof (GtkCellAreaPrivate));
}
/*************************************************************
};
G_DEFINE_TYPE_WITH_CODE (GtkCellAreaBox, gtk_cell_area_box, GTK_TYPE_CELL_AREA,
+ G_ADD_PRIVATE (GtkCellAreaBox)
G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
gtk_cell_area_box_cell_layout_init)
- G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL));
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL))
static void
gtk_cell_area_box_init (GtkCellAreaBox *box)
{
GtkCellAreaBoxPrivate *priv;
- box->priv = G_TYPE_INSTANCE_GET_PRIVATE (box,
- GTK_TYPE_CELL_AREA_BOX,
- GtkCellAreaBoxPrivate);
+ box->priv = gtk_cell_area_box_get_instance_private (box);
priv = box->priv;
priv->orientation = GTK_ORIENTATION_HORIZONTAL;
"reference to the start or end of the cell area"),
GTK_TYPE_PACK_TYPE, GTK_PACK_START,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (object_class, sizeof (GtkCellAreaBoxPrivate));
}
gboolean *align;
};
-G_DEFINE_TYPE (GtkCellAreaBoxContext, _gtk_cell_area_box_context, GTK_TYPE_CELL_AREA_CONTEXT);
+G_DEFINE_TYPE_WITH_PRIVATE (GtkCellAreaBoxContext, _gtk_cell_area_box_context, GTK_TYPE_CELL_AREA_CONTEXT)
static void
free_cache_array (GArray *array)
{
GtkCellAreaBoxContextPrivate *priv;
- box_context->priv = G_TYPE_INSTANCE_GET_PRIVATE (box_context,
- GTK_TYPE_CELL_AREA_BOX_CONTEXT,
- GtkCellAreaBoxContextPrivate);
+ box_context->priv = _gtk_cell_area_box_context_get_instance_private (box_context);
priv = box_context->priv;
priv->base_widths = g_array_new (FALSE, TRUE, sizeof (CachedSize));
context_class->reset = _gtk_cell_area_box_context_reset;
context_class->get_preferred_height_for_width = _gtk_cell_area_box_context_get_preferred_height_for_width;
context_class->get_preferred_width_for_height = _gtk_cell_area_box_context_get_preferred_width_for_height;
-
- g_type_class_add_private (object_class, sizeof (GtkCellAreaBoxContextPrivate));
}
/*************************************************************
PROP_NAT_HEIGHT
};
-G_DEFINE_TYPE (GtkCellAreaContext, gtk_cell_area_context, G_TYPE_OBJECT);
+G_DEFINE_TYPE_WITH_PRIVATE (GtkCellAreaContext, gtk_cell_area_context, G_TYPE_OBJECT)
static void
gtk_cell_area_context_init (GtkCellAreaContext *context)
{
- context->priv = G_TYPE_INSTANCE_GET_PRIVATE (context,
- GTK_TYPE_CELL_AREA_CONTEXT,
- GtkCellAreaContextPrivate);
+ context->priv = gtk_cell_area_context_get_instance_private (context);
}
static void
G_MAXINT,
-1,
G_PARAM_READABLE));
-
- g_type_class_add_private (object_class, sizeof (GtkCellAreaContextPrivate));
}
/*************************************************************
LAST_SIGNAL
};
+static gint GtkCellRenderer_private_offset;
static guint cell_renderer_signals[LAST_SIGNAL] = { 0 };
+static inline gpointer
+gtk_cell_renderer_get_instance_private (GtkCellRenderer *self)
+{
+ return (G_STRUCT_MEMBER_P (self, GtkCellRenderer_private_offset));
+}
+
static void
gtk_cell_renderer_init (GtkCellRenderer *cell)
{
GtkCellRendererPrivate *priv;
- cell->priv = G_TYPE_INSTANCE_GET_PRIVATE (cell,
- GTK_TYPE_CELL_RENDERER,
- GtkCellRendererPrivate);
+ cell->priv = gtk_cell_renderer_get_instance_private (cell);
priv = cell->priv;
priv->mode = GTK_CELL_RENDERER_MODE_INERT;
P_("Cell background set"),
P_("Whether the cell background color is set"));
- g_type_class_add_private (class, sizeof (GtkCellRendererPrivate));
+ if (GtkCellRenderer_private_offset != 0)
+ g_type_class_adjust_private_offset (class, &GtkCellRenderer_private_offset);
gtk_cell_renderer_class_set_accessible_type (class, GTK_TYPE_RENDERER_CELL_ACCESSIBLE);
}
cell_renderer_type = g_type_register_static (G_TYPE_INITIALLY_UNOWNED, "GtkCellRenderer",
&cell_renderer_info, G_TYPE_FLAG_ABSTRACT);
+ GtkCellRenderer_private_offset =
+ g_type_add_instance_private (cell_renderer_type, sizeof (GtkCellRendererPrivate));
g_type_add_class_private (cell_renderer_type, sizeof (GtkCellRendererClassPrivate));
}
static guint signals[LAST_SIGNAL] = { 0 };
-G_DEFINE_TYPE (GtkCellRendererAccel, gtk_cell_renderer_accel, GTK_TYPE_CELL_RENDERER_TEXT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkCellRendererAccel, gtk_cell_renderer_accel, GTK_TYPE_CELL_RENDERER_TEXT)
static void
gtk_cell_renderer_accel_init (GtkCellRendererAccel *cell_accel)
{
gchar *text;
- cell_accel->priv = G_TYPE_INSTANCE_GET_PRIVATE (cell_accel,
- GTK_TYPE_CELL_RENDERER_ACCEL,
- GtkCellRendererAccelPrivate);
+ cell_accel->priv = gtk_cell_renderer_accel_get_instance_private (cell_accel);
text = convert_keysym_state_to_string (cell_accel, 0, 0, 0);
g_object_set (cell_accel, "text", text, NULL);
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1,
G_TYPE_STRING);
-
- g_type_class_add_private (cell_accel_class, sizeof (GtkCellRendererAccelPrivate));
}
#define GTK_CELL_RENDERER_COMBO_PATH "gtk-cell-renderer-combo-path"
-G_DEFINE_TYPE (GtkCellRendererCombo, gtk_cell_renderer_combo, GTK_TYPE_CELL_RENDERER_TEXT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkCellRendererCombo, gtk_cell_renderer_combo, GTK_TYPE_CELL_RENDERER_TEXT)
static void
gtk_cell_renderer_combo_class_init (GtkCellRendererComboClass *klass)
G_TYPE_NONE, 2,
G_TYPE_STRING,
GTK_TYPE_TREE_ITER);
-
- g_type_class_add_private (klass, sizeof (GtkCellRendererComboPrivate));
}
static void
{
GtkCellRendererComboPrivate *priv;
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
- GTK_TYPE_CELL_RENDERER_COMBO,
- GtkCellRendererComboPrivate);
+ self->priv = gtk_cell_renderer_combo_get_instance_private (self);
priv = self->priv;
priv->model = NULL;
gchar *stock_detail;
};
-
-G_DEFINE_TYPE (GtkCellRendererPixbuf, gtk_cell_renderer_pixbuf, GTK_TYPE_CELL_RENDERER)
-
+G_DEFINE_TYPE_WITH_PRIVATE (GtkCellRendererPixbuf, gtk_cell_renderer_pixbuf, GTK_TYPE_CELL_RENDERER)
static void
gtk_cell_renderer_pixbuf_init (GtkCellRendererPixbuf *cellpixbuf)
{
GtkCellRendererPixbufPrivate *priv;
- cellpixbuf->priv = G_TYPE_INSTANCE_GET_PRIVATE (cellpixbuf,
- GTK_TYPE_CELL_RENDERER_PIXBUF,
- GtkCellRendererPixbufPrivate);
+ cellpixbuf->priv = gtk_cell_renderer_pixbuf_get_instance_private (cellpixbuf);
priv = cellpixbuf->priv;
+
priv->icon_helper = _gtk_icon_helper_new ();
priv->icon_size = GTK_ICON_SIZE_MENU;
}
- g_type_class_add_private (object_class, sizeof (GtkCellRendererPixbufPrivate));
-
gtk_cell_renderer_class_set_accessible_type (cell_class, GTK_TYPE_IMAGE_CELL_ACCESSIBLE);
}
G_DEFINE_TYPE_WITH_CODE (GtkCellRendererProgress, gtk_cell_renderer_progress, GTK_TYPE_CELL_RENDERER,
+ G_ADD_PRIVATE (GtkCellRendererProgress)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL))
static void
P_("Invert the direction in which the progress bar grows"),
FALSE,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (object_class,
- sizeof (GtkCellRendererProgressPrivate));
}
static void
{
GtkCellRendererProgressPrivate *priv;
- cellprogress->priv = G_TYPE_INSTANCE_GET_PRIVATE (cellprogress,
- GTK_TYPE_CELL_RENDERER_PROGRESS,
- GtkCellRendererProgressPrivate);
+ cellprogress->priv = gtk_cell_renderer_progress_get_instance_private (cellprogress);
priv = cellprogress->priv;
priv->value = 0;
#define GTK_CELL_RENDERER_SPIN_PATH "gtk-cell-renderer-spin-path"
-G_DEFINE_TYPE (GtkCellRendererSpin, gtk_cell_renderer_spin, GTK_TYPE_CELL_RENDERER_TEXT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkCellRendererSpin, gtk_cell_renderer_spin, GTK_TYPE_CELL_RENDERER_TEXT)
static void
P_("The number of decimal places to display"),
0, 20, 0,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (object_class, sizeof (GtkCellRendererSpinPrivate));
}
static void
{
GtkCellRendererSpinPrivate *priv;
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
- GTK_TYPE_CELL_RENDERER_SPIN,
- GtkCellRendererSpinPrivate);
+ self->priv = gtk_cell_renderer_spin_get_instance_private (self);
priv = self->priv;
priv->adjustment = NULL;
const GdkRectangle *cell_area,
GtkCellRendererState flags);
-G_DEFINE_TYPE (GtkCellRendererSpinner, gtk_cell_renderer_spinner, GTK_TYPE_CELL_RENDERER)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkCellRendererSpinner, gtk_cell_renderer_spinner, GTK_TYPE_CELL_RENDERER)
static void
gtk_cell_renderer_spinner_class_init (GtkCellRendererSpinnerClass *klass)
GTK_TYPE_ICON_SIZE, GTK_ICON_SIZE_MENU,
G_PARAM_READWRITE));
-
- g_type_class_add_private (object_class, sizeof (GtkCellRendererSpinnerPrivate));
}
static void
gtk_cell_renderer_spinner_init (GtkCellRendererSpinner *cell)
{
- cell->priv = G_TYPE_INSTANCE_GET_PRIVATE (cell,
- GTK_TYPE_CELL_RENDERER_SPINNER,
- GtkCellRendererSpinnerPrivate);
-
+ cell->priv = gtk_cell_renderer_spinner_get_instance_private (cell);
cell->priv->pulse = 0;
cell->priv->old_icon_size = GTK_ICON_SIZE_INVALID;
cell->priv->icon_size = GTK_ICON_SIZE_MENU;
gulong entry_menu_popdown_timeout;
};
-G_DEFINE_TYPE (GtkCellRendererText, gtk_cell_renderer_text, GTK_TYPE_CELL_RENDERER)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkCellRendererText, gtk_cell_renderer_text, GTK_TYPE_CELL_RENDERER)
static void
gtk_cell_renderer_text_init (GtkCellRendererText *celltext)
GtkCellRendererTextPrivate *priv;
GtkCellRenderer *cell = GTK_CELL_RENDERER (celltext);
- celltext->priv = G_TYPE_INSTANCE_GET_PRIVATE (celltext,
- GTK_TYPE_CELL_RENDERER_TEXT,
- GtkCellRendererTextPrivate);
+ celltext->priv = gtk_cell_renderer_text_get_instance_private (celltext);
priv = celltext->priv;
gtk_cell_renderer_set_alignment (cell, 0.0, 0.5);
G_TYPE_STRING,
G_TYPE_STRING);
- g_type_class_add_private (object_class, sizeof (GtkCellRendererTextPrivate));
-
gtk_cell_renderer_class_set_accessible_type (cell_class, GTK_TYPE_TEXT_CELL_ACCESSIBLE);
}
};
-G_DEFINE_TYPE (GtkCellRendererToggle, gtk_cell_renderer_toggle, GTK_TYPE_CELL_RENDERER)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkCellRendererToggle, gtk_cell_renderer_toggle, GTK_TYPE_CELL_RENDERER)
static void
{
GtkCellRendererTogglePrivate *priv;
- celltoggle->priv = G_TYPE_INSTANCE_GET_PRIVATE (celltoggle,
- GTK_TYPE_CELL_RENDERER_TOGGLE,
- GtkCellRendererTogglePrivate);
+ celltoggle->priv = gtk_cell_renderer_toggle_get_instance_private (celltoggle);
priv = celltoggle->priv;
priv->activatable = TRUE;
G_TYPE_NONE, 1,
G_TYPE_STRING);
- g_type_class_add_private (object_class, sizeof (GtkCellRendererTogglePrivate));
-
gtk_cell_renderer_class_set_accessible_type (cell_class, GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE);
}
PROP_FIT_MODEL
};
-G_DEFINE_TYPE_WITH_CODE (GtkCellView, gtk_cell_view, GTK_TYPE_WIDGET,
+G_DEFINE_TYPE_WITH_CODE (GtkCellView, gtk_cell_view, GTK_TYPE_WIDGET,
+ G_ADD_PRIVATE (GtkCellView)
G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
gtk_cell_view_cell_layout_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_cell_view_buildable_init)
- G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL));
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL))
static void
gtk_cell_view_class_init (GtkCellViewClass *klass)
ADD_SET_PROP ("background-set", PROP_BACKGROUND_SET,
P_("Background set"),
P_("Whether this tag affects the background color"));
-
- g_type_class_add_private (gobject_class, sizeof (GtkCellViewPrivate));
}
static void
static void
gtk_cell_view_init (GtkCellView *cellview)
{
- GtkCellViewPrivate *priv;
-
- cellview->priv = G_TYPE_INSTANCE_GET_PRIVATE (cellview,
- GTK_TYPE_CELL_VIEW,
- GtkCellViewPrivate);
- priv = cellview->priv;
+ cellview->priv = gtk_cell_view_get_instance_private (cellview);
+ cellview->priv->orientation = GTK_ORIENTATION_HORIZONTAL;
gtk_widget_set_has_window (GTK_WIDGET (cellview), FALSE);
-
- priv->orientation = GTK_ORIENTATION_HORIZONTAL;
}
static void
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
G_DEFINE_TYPE_WITH_CODE (GtkCheckMenuItem, gtk_check_menu_item, GTK_TYPE_MENU_ITEM,
+ G_ADD_PRIVATE (GtkCheckMenuItem)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,
gtk_check_menu_item_activatable_interface_init))
G_GNUC_END_IGNORE_DEPRECATIONS;
NULL, NULL,
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
- g_type_class_add_private (klass, sizeof (GtkCheckMenuItemPrivate));
}
static void
static void
gtk_check_menu_item_init (GtkCheckMenuItem *check_menu_item)
{
- GtkCheckMenuItemPrivate *priv;
-
- check_menu_item->priv = G_TYPE_INSTANCE_GET_PRIVATE (check_menu_item,
- GTK_TYPE_CHECK_MENU_ITEM,
- GtkCheckMenuItemPrivate);
- priv = check_menu_item->priv;
-
- priv->active = FALSE;
+ check_menu_item->priv = gtk_check_menu_item_get_instance_private (check_menu_item);
+ check_menu_item->priv->active = FALSE;
}
static gint
static void gtk_color_button_iface_init (GtkColorChooserInterface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkColorButton, gtk_color_button, GTK_TYPE_BUTTON,
+ G_ADD_PRIVATE (GtkColorButton)
G_IMPLEMENT_INTERFACE (GTK_TYPE_COLOR_CHOOSER,
gtk_color_button_iface_init))
NULL, NULL,
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
- g_type_class_add_private (gobject_class, sizeof (GtkColorButtonPrivate));
}
static gboolean
PangoRectangle rect;
/* Create the widgets */
- button->priv = G_TYPE_INSTANCE_GET_PRIVATE (button,
- GTK_TYPE_COLOR_BUTTON,
- GtkColorButtonPrivate);
+ button->priv = gtk_color_button_get_instance_private (button);
button->priv->draw_area = gtk_drawing_area_new ();
layout = gtk_widget_create_pango_layout (GTK_WIDGET (button), "Black");
static void gtk_color_chooser_dialog_iface_init (GtkColorChooserInterface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkColorChooserDialog, gtk_color_chooser_dialog, GTK_TYPE_DIALOG,
+ G_ADD_PRIVATE (GtkColorChooserDialog)
G_IMPLEMENT_INTERFACE (GTK_TYPE_COLOR_CHOOSER,
gtk_color_chooser_dialog_iface_init))
static void
gtk_color_chooser_dialog_init (GtkColorChooserDialog *cc)
{
- cc->priv = G_TYPE_INSTANCE_GET_PRIVATE (cc,
- GTK_TYPE_COLOR_CHOOSER_DIALOG,
- GtkColorChooserDialogPrivate);
+ cc->priv = gtk_color_chooser_dialog_get_instance_private (cc);
gtk_widget_init_template (GTK_WIDGET (cc));
}
gtk_widget_class_bind_callback (widget_class, selected_cb);
gtk_widget_class_bind_callback (widget_class, propagate_notify);
gtk_widget_class_bind_callback (widget_class, color_activated_cb);
-
- g_type_class_add_private (class, sizeof (GtkColorChooserDialogPrivate));
}
static void
static void gtk_color_chooser_widget_iface_init (GtkColorChooserInterface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkColorChooserWidget, gtk_color_chooser_widget, GTK_TYPE_BOX,
+ G_ADD_PRIVATE (GtkColorChooserWidget)
G_IMPLEMENT_INTERFACE (GTK_TYPE_COLOR_CHOOSER,
gtk_color_chooser_widget_iface_init))
AtkObject *atk_obj;
gchar *text, *name;
- cc->priv = G_TYPE_INSTANCE_GET_PRIVATE (cc, GTK_TYPE_COLOR_CHOOSER_WIDGET, GtkColorChooserWidgetPrivate);
+ cc->priv = gtk_color_chooser_widget_get_instance_private (cc);
cc->priv->use_alpha = TRUE;
g_object_class_install_property (object_class, PROP_SHOW_EDITOR,
g_param_spec_boolean ("show-editor", P_("Show editor"), P_("Show editor"),
FALSE, GTK_PARAM_READWRITE));
-
- g_type_class_add_private (object_class, sizeof (GtkColorChooserWidgetPrivate));
}
/* GtkColorChooser implementation {{{1 */
static void gtk_color_editor_iface_init (GtkColorChooserInterface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkColorEditor, gtk_color_editor, GTK_TYPE_BOX,
+ G_ADD_PRIVATE (GtkColorEditor)
G_IMPLEMENT_INTERFACE (GTK_TYPE_COLOR_CHOOSER,
gtk_color_editor_iface_init))
{
GdkRGBA transparent = { 0, 0, 0, 0 };
- editor->priv = G_TYPE_INSTANCE_GET_PRIVATE (editor,
- GTK_TYPE_COLOR_EDITOR,
- GtkColorEditorPrivate);
+ editor->priv = gtk_color_editor_get_instance_private (editor);
editor->priv->use_alpha = TRUE;
g_type_ensure (GTK_TYPE_COLOR_SCALE);
gtk_widget_class_bind_callback (widget_class, entry_apply);
gtk_widget_class_bind_callback (widget_class, entry_focus_out);
gtk_widget_class_bind_callback (widget_class, popup_edit);
-
- g_type_class_add_private (class, sizeof (GtkColorEditorPrivate));
}
static void
PROP_V_ADJUSTMENT
};
-G_DEFINE_TYPE (GtkColorPlane, gtk_color_plane, GTK_TYPE_DRAWING_AREA)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkColorPlane, gtk_color_plane, GTK_TYPE_DRAWING_AREA)
static void
sv_to_xy (GtkColorPlane *plane,
{
AtkObject *atk_obj;
- plane->priv = G_TYPE_INSTANCE_GET_PRIVATE (plane,
- GTK_TYPE_COLOR_PLANE,
- GtkColorPlanePrivate);
+ plane->priv = gtk_color_plane_get_instance_private (plane);
gtk_widget_set_can_focus (GTK_WIDGET (plane), TRUE);
gtk_widget_set_events (GTK_WIDGET (plane), GDK_KEY_PRESS_MASK
GTK_TYPE_ADJUSTMENT,
G_PARAM_WRITABLE |
G_PARAM_CONSTRUCT_ONLY));
-
- g_type_class_add_private (class, sizeof (GtkColorPlanePrivate));
}
GtkWidget *
GtkAdjustment *s_adj,
GtkAdjustment *v_adj)
{
- GtkColorPlane *plane;
-
- plane = (GtkColorPlane *) g_object_new (GTK_TYPE_COLOR_PLANE,
- "h-adjustment", h_adj,
- "s-adjustment", s_adj,
- "v-adjustment", v_adj,
- NULL);
-
- return (GtkWidget *)plane;
+ return g_object_new (GTK_TYPE_COLOR_PLANE,
+ "h-adjustment", h_adj,
+ "s-adjustment", s_adj,
+ "v-adjustment", v_adj,
+ NULL);
}
PROP_SCALE_TYPE
};
-G_DEFINE_TYPE (GtkColorScale, gtk_color_scale, GTK_TYPE_SCALE)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkColorScale, gtk_color_scale, GTK_TYPE_SCALE)
static void
gtk_color_scale_get_trough_size (GtkColorScale *scale,
static void
gtk_color_scale_init (GtkColorScale *scale)
{
- scale->priv = G_TYPE_INSTANCE_GET_PRIVATE (scale,
- GTK_TYPE_COLOR_SCALE,
- GtkColorScalePrivate);
+ scale->priv = gtk_color_scale_get_instance_private (scale);
+
gtk_widget_add_events (GTK_WIDGET (scale), GDK_TOUCH_MASK);
}
g_param_spec_int ("scale-type", P_("Scale type"), P_("Scale type"),
0, 1, 0,
GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
-
- g_type_class_add_private (class, sizeof (GtkColorScalePrivate));
}
void
gtk_color_scale_new (GtkAdjustment *adjustment,
GtkColorScaleType type)
{
- return (GtkWidget *) g_object_new (GTK_TYPE_COLOR_SCALE,
- "adjustment", adjustment,
- "draw-value", FALSE,
- "scale-type", type,
- NULL);
+ return g_object_new (GTK_TYPE_COLOR_SCALE,
+ "adjustment", adjustment,
+ "draw-value", FALSE,
+ "scale-type", type,
+ NULL);
}
static guint signals[LAST_SIGNAL];
-G_DEFINE_TYPE (GtkColorSwatch, gtk_color_swatch, GTK_TYPE_WIDGET)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkColorSwatch, gtk_color_swatch, GTK_TYPE_WIDGET)
static void
gtk_color_swatch_init (GtkColorSwatch *swatch)
{
- swatch->priv = G_TYPE_INSTANCE_GET_PRIVATE (swatch,
- GTK_TYPE_COLOR_SWATCH,
- GtkColorSwatchPrivate);
+ swatch->priv = gtk_color_swatch_get_instance_private (swatch);
+ swatch->priv->use_alpha = TRUE;
+ swatch->priv->selectable = TRUE;
gtk_widget_set_can_focus (GTK_WIDGET (swatch), TRUE);
gtk_widget_set_has_window (GTK_WIDGET (swatch), FALSE);
-
- swatch->priv->use_alpha = TRUE;
- swatch->priv->selectable = TRUE;
}
#define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)
g_param_spec_boolean ("selectable", P_("Selectable"), P_("Whether the swatch is selectable"),
TRUE, GTK_PARAM_READWRITE));
- g_type_class_add_private (object_class, sizeof (GtkColorSwatchPrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_COLOR_SWATCH_ACCESSIBLE);
}
GtkTextDirection previous_direction);
G_DEFINE_TYPE_WITH_CODE (GtkComboBox, gtk_combo_box, GTK_TYPE_BIN,
+ G_ADD_PRIVATE (GtkComboBox)
G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
gtk_combo_box_cell_layout_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_EDITABLE,
GTK_SHADOW_NONE,
GTK_PARAM_READABLE));
- g_type_class_add_private (object_class, sizeof (GtkComboBoxPrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_COMBO_BOX_ACCESSIBLE);
}
{
GtkComboBoxPrivate *priv;
- combo_box->priv = G_TYPE_INSTANCE_GET_PRIVATE (combo_box,
- GTK_TYPE_COMBO_BOX,
- GtkComboBoxPrivate);
+ combo_box->priv = gtk_combo_box_get_instance_private (combo_box);
priv = combo_box->priv;
priv->wrap_width = 0;
static const gchar hadjustment_key[] = "gtk-hadjustment";
static guint hadjustment_key_id = 0;
static guint container_signals[LAST_SIGNAL] = { 0 };
+static gint GtkContainer_private_offset;
static GtkWidgetClass *parent_class = NULL;
extern GParamSpecPool *_gtk_widget_child_property_pool;
extern GObjectNotifyContext *_gtk_widget_child_property_notify_context;
/* --- functions --- */
+static inline gpointer
+gtk_container_get_instance_private (GtkContainer *self)
+{
+ return G_STRUCT_MEMBER_P (self, GtkContainer_private_offset);
+}
+
GType
gtk_container_get_type (void)
{
g_type_register_static (GTK_TYPE_WIDGET, I_("GtkContainer"),
&container_info, G_TYPE_FLAG_ABSTRACT);
+ GtkContainer_private_offset =
+ g_type_add_instance_private (container_type, sizeof (GtkContainerPrivate));
+
g_type_add_interface_static (container_type,
GTK_TYPE_BUILDABLE,
&buildable_info);
G_TYPE_NONE, 1,
GTK_TYPE_WIDGET);
- g_type_class_add_private (class, sizeof (GtkContainerPrivate));
+ if (GtkContainer_private_offset != 0)
+ g_type_class_adjust_private_offset (class, &GtkContainer_private_offset);
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_CONTAINER_ACCESSIBLE);
}
{
GtkContainerPrivate *priv;
- container->priv = G_TYPE_INSTANCE_GET_PRIVATE (container,
- GTK_TYPE_CONTAINER,
- GtkContainerPrivate);
+ container->priv = gtk_container_get_instance_private (container);
priv = container->priv;
priv->focus_child = NULL;
}
G_DEFINE_TYPE_EXTENDED (GtkCssProvider, gtk_css_provider, G_TYPE_OBJECT, 0,
+ G_ADD_PRIVATE (GtkCssProvider)
G_IMPLEMENT_INTERFACE (GTK_TYPE_STYLE_PROVIDER,
gtk_css_style_provider_iface_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_STYLE_PROVIDER_PRIVATE,
object_class->finalize = gtk_css_provider_finalize;
klass->parsing_error = gtk_css_provider_parsing_error;
-
- g_type_class_add_private (object_class, sizeof (GtkCssProviderPrivate));
}
static void
{
GtkCssProviderPrivate *priv;
- priv = css_provider->priv = G_TYPE_INSTANCE_GET_PRIVATE (css_provider,
- GTK_TYPE_CSS_PROVIDER,
- GtkCssProviderPrivate);
+ priv = css_provider->priv = gtk_css_provider_get_instance_private (css_provider);
priv->rulesets = g_array_new (FALSE, FALSE, sizeof (GtkCssRuleset));
};
-G_DEFINE_TYPE (GtkCustomPaperUnixDialog, gtk_custom_paper_unix_dialog, GTK_TYPE_DIALOG)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkCustomPaperUnixDialog, gtk_custom_paper_unix_dialog, GTK_TYPE_DIALOG)
static void gtk_custom_paper_unix_dialog_finalize (GObject *object);
static void
gtk_custom_paper_unix_dialog_class_init (GtkCustomPaperUnixDialogClass *class)
{
- GObjectClass *object_class;
-
- object_class = (GObjectClass *) class;
-
- object_class->finalize = gtk_custom_paper_unix_dialog_finalize;
-
- g_type_class_add_private (class, sizeof (GtkCustomPaperUnixDialogPrivate));
+ G_OBJECT_CLASS (class)->finalize = gtk_custom_paper_unix_dialog_finalize;
}
static void
GtkCustomPaperUnixDialogPrivate *priv;
GtkTreeIter iter;
- dialog->priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog,
- GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG,
- GtkCustomPaperUnixDialogPrivate);
+ dialog->priv = gtk_custom_paper_unix_dialog_get_instance_private (dialog);
priv = dialog->priv;
priv->print_backends = NULL;
static guint dialog_signals[LAST_SIGNAL];
G_DEFINE_TYPE_WITH_CODE (GtkDialog, gtk_dialog, GTK_TYPE_WINDOW,
+ G_ADD_PRIVATE (GtkDialog)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_dialog_buildable_interface_init))
static void
gtk_dialog_class_init (GtkDialogClass *class)
{
- GObjectClass *gobject_class;
GtkWidgetClass *widget_class;
GtkBindingSet *binding_set;
- gobject_class = G_OBJECT_CLASS (class);
widget_class = GTK_WIDGET_CLASS (class);
widget_class->map = gtk_dialog_map;
class->close = gtk_dialog_close;
- g_type_class_add_private (gobject_class, sizeof (GtkDialogPrivate));
-
/**
* GtkDialog::response:
* @dialog: the object on which the signal is emitted
static void
gtk_dialog_init (GtkDialog *dialog)
{
- dialog->priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog,
- GTK_TYPE_DIALOG,
- GtkDialogPrivate);
+ dialog->priv = gtk_dialog_get_instance_private (dialog);
gtk_widget_init_template (GTK_WIDGET (dialog));
static GtkEntryBuffer *get_buffer (GtkEntry *entry);
G_DEFINE_TYPE_WITH_CODE (GtkEntry, gtk_entry, GTK_TYPE_WIDGET,
+ G_ADD_PRIVATE (GtkEntry)
G_IMPLEMENT_INTERFACE (GTK_TYPE_EDITABLE,
gtk_entry_editable_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_EDITABLE,
GTK_PARAM_READABLE |
G_PARAM_DEPRECATED));
- g_type_class_add_private (gobject_class, sizeof (GtkEntryPrivate));
test_touchscreen = g_getenv ("GTK_TEST_TOUCHSCREEN") != NULL;
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_ENTRY_ACCESSIBLE);
GtkStyleContext *context;
GtkEntryPrivate *priv;
- entry->priv = G_TYPE_INSTANCE_GET_PRIVATE (entry,
- GTK_TYPE_ENTRY,
- GtkEntryPrivate);
+ entry->priv = gtk_entry_get_instance_private (entry);
priv = entry->priv;
gtk_widget_set_can_focus (GTK_WIDGET (entry), TRUE);
gint max_length;
};
-G_DEFINE_TYPE (GtkEntryBuffer, gtk_entry_buffer, G_TYPE_OBJECT);
+G_DEFINE_TYPE_WITH_PRIVATE (GtkEntryBuffer, gtk_entry_buffer, G_TYPE_OBJECT)
/* --------------------------------------------------------------------------------
* DEFAULT IMPLEMENTATIONS OF TEXT BUFFER
{
GtkEntryBufferPrivate *pv;
- pv = buffer->priv = G_TYPE_INSTANCE_GET_PRIVATE (buffer, GTK_TYPE_ENTRY_BUFFER, GtkEntryBufferPrivate);
+ pv = buffer->priv = gtk_entry_buffer_get_instance_private (buffer);
pv->normal_text = NULL;
pv->normal_text_chars = 0;
klass->inserted_text = gtk_entry_buffer_real_inserted_text;
klass->deleted_text = gtk_entry_buffer_real_deleted_text;
- g_type_class_add_private (gobject_class, sizeof (GtkEntryBufferPrivate));
-
/**
* GtkEntryBuffer:text:
*
static void gtk_entry_completion_buildable_init (GtkBuildableIface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkEntryCompletion, gtk_entry_completion, G_TYPE_OBJECT,
+ G_ADD_PRIVATE (GtkEntryCompletion)
G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
gtk_entry_completion_cell_layout_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
P_("The GtkCellArea used to layout cells"),
GTK_TYPE_CELL_AREA,
GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
-
- g_type_class_add_private (object_class, sizeof (GtkEntryCompletionPrivate));
}
GtkEntryCompletionPrivate *priv;
/* yes, also priv, need to keep the code readable */
- completion->priv = G_TYPE_INSTANCE_GET_PRIVATE (completion,
- GTK_TYPE_ENTRY_COMPLETION,
- GtkEntryCompletionPrivate);
+ completion->priv = gtk_entry_completion_get_instance_private (completion);
priv = completion->priv;
priv->minimum_key_length = 1;
GValue *value,
GParamSpec *pspec);
-G_DEFINE_TYPE (GtkEventBox, gtk_event_box, GTK_TYPE_BIN)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkEventBox, gtk_event_box, GTK_TYPE_BIN)
static void
gtk_event_box_class_init (GtkEventBoxClass *class)
P_("Whether the event-trapping window of the eventbox is above the window of the child widget as opposed to below it."),
FALSE,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (class, sizeof (GtkEventBoxPrivate));
}
static void
gtk_event_box_init (GtkEventBox *event_box)
{
- GtkEventBoxPrivate *priv;
-
gtk_widget_set_has_window (GTK_WIDGET (event_box), TRUE);
- priv = G_TYPE_INSTANCE_GET_PRIVATE (event_box,
- GTK_TYPE_EVENT_BOX,
- GtkEventBoxPrivate);
-
- event_box->priv = priv;
- priv->above_child = FALSE;
+ event_box->priv = gtk_event_box_get_instance_private (event_box);
+ event_box->priv->above_child = FALSE;
}
/**
gint *natural_height);
G_DEFINE_TYPE_WITH_CODE (GtkExpander, gtk_expander, GTK_TYPE_BIN,
+ G_ADD_PRIVATE (GtkExpander)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_expander_buildable_init))
klass->activate = gtk_expander_activate;
- g_type_class_add_private (klass, sizeof (GtkExpanderPrivate));
-
g_object_class_install_property (gobject_class,
PROP_EXPANDED,
g_param_spec_boolean ("expanded",
{
GtkExpanderPrivate *priv;
- expander->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (expander,
- GTK_TYPE_EXPANDER,
- GtkExpanderPrivate);
+ expander->priv = priv = gtk_expander_get_instance_private (expander);
gtk_widget_set_can_focus (GTK_WIDGET (expander), TRUE);
gtk_widget_set_has_window (GTK_WIDGET (expander), FALSE);
* GType Declaration *
* ******************* */
-G_DEFINE_TYPE_WITH_CODE (GtkFileChooserButton, gtk_file_chooser_button, GTK_TYPE_BOX, { \
- G_IMPLEMENT_INTERFACE (GTK_TYPE_FILE_CHOOSER, gtk_file_chooser_button_file_chooser_iface_init) \
-})
+G_DEFINE_TYPE_WITH_CODE (GtkFileChooserButton, gtk_file_chooser_button, GTK_TYPE_BOX,
+ G_ADD_PRIVATE (GtkFileChooserButton)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_FILE_CHOOSER,
+ gtk_file_chooser_button_file_chooser_iface_init))
/* ***************** *
gtk_widget_class_bind_callback (widget_class, button_clicked_cb);
gtk_widget_class_bind_callback (widget_class, combo_box_changed_cb);
gtk_widget_class_bind_callback (widget_class, combo_box_notify_popup_shown_cb);
-
- g_type_class_add_private (class, sizeof (GtkFileChooserButtonPrivate));
}
static void
GtkFileChooserButtonPrivate *priv;
GtkTargetList *target_list;
- priv = button->priv = G_TYPE_INSTANCE_GET_PRIVATE (button,
- GTK_TYPE_FILE_CHOOSER_BUTTON,
- GtkFileChooserButtonPrivate);
+ priv = button->priv = gtk_file_chooser_button_get_instance_private (button);
priv->icon_size = FALLBACK_ICON_SIZE;
priv->focus_on_click = TRUE;
\f
G_DEFINE_TYPE_WITH_CODE (GtkFileChooserDefault, _gtk_file_chooser_default, GTK_TYPE_BOX,
+ G_ADD_PRIVATE (GtkFileChooserDefault)
G_IMPLEMENT_INTERFACE (GTK_TYPE_FILE_CHOOSER,
gtk_file_chooser_default_iface_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_FILE_CHOOSER_EMBED,
_gtk_file_chooser_install_properties (gobject_class);
- g_type_class_add_private (gobject_class, sizeof (GtkFileChooserDefaultPrivate));
-
/* Bind class to template */
gtk_widget_class_set_template_from_resource (widget_class,
#ifdef PROFILE_FILE_CHOOSER
access ("MARK: *** CREATE FILE CHOOSER", F_OK);
#endif
- impl->priv = G_TYPE_INSTANCE_GET_PRIVATE (impl,
- GTK_TYPE_FILE_CHOOSER_DEFAULT,
- GtkFileChooserDefaultPrivate);
+ impl->priv = _gtk_file_chooser_default_get_instance_private (impl);
priv = impl->priv;
priv->local_only = TRUE;
gboolean response_requested;
};
-#define GTK_FILE_CHOOSER_DIALOG_GET_PRIVATE(o) (GTK_FILE_CHOOSER_DIALOG (o)->priv)
-
static void gtk_file_chooser_dialog_set_property (GObject *object,
guint prop_id,
const GValue *value,
gint response_id);
G_DEFINE_TYPE_WITH_CODE (GtkFileChooserDialog, gtk_file_chooser_dialog, GTK_TYPE_DIALOG,
+ G_ADD_PRIVATE (GtkFileChooserDialog)
G_IMPLEMENT_INTERFACE (GTK_TYPE_FILE_CHOOSER,
_gtk_file_chooser_delegate_iface_init))
gtk_widget_class_bind_callback (widget_class, file_chooser_widget_file_activated);
gtk_widget_class_bind_callback (widget_class, file_chooser_widget_default_size_changed);
gtk_widget_class_bind_callback (widget_class, file_chooser_widget_response_requested);
-
- g_type_class_add_private (class, sizeof (GtkFileChooserDialogPrivate));
}
static void
gtk_file_chooser_dialog_init (GtkFileChooserDialog *dialog)
{
- GtkFileChooserDialogPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog,
- GTK_TYPE_FILE_CHOOSER_DIALOG,
- GtkFileChooserDialogPrivate);
- dialog->priv = priv;
+ dialog->priv = gtk_file_chooser_dialog_get_instance_private (dialog);
dialog->priv->response_requested = FALSE;
gtk_widget_init_template (GTK_WIDGET (dialog));
_gtk_file_chooser_set_delegate (GTK_FILE_CHOOSER (dialog),
- GTK_FILE_CHOOSER (priv->widget));
+ GTK_FILE_CHOOSER (dialog->priv->widget));
}
static gboolean
gint default_width, default_height;
GtkRequisition req, widget_req;
- priv = GTK_FILE_CHOOSER_DIALOG_GET_PRIVATE (dialog);
+ priv = gtk_file_chooser_dialog_get_instance_private (dialog);
/* Unset any previously set size */
gtk_widget_set_size_request (GTK_WIDGET (dialog), -1, -1);
GParamSpec *pspec)
{
- GtkFileChooserDialogPrivate *priv = GTK_FILE_CHOOSER_DIALOG_GET_PRIVATE (object);
+ GtkFileChooserDialogPrivate *priv;
+
+ priv = gtk_file_chooser_dialog_get_instance_private (GTK_FILE_CHOOSER_DIALOG (object));
switch (prop_id)
{
GValue *value,
GParamSpec *pspec)
{
- GtkFileChooserDialogPrivate *priv = GTK_FILE_CHOOSER_DIALOG_GET_PRIVATE (object);
+ GtkFileChooserDialogPrivate *priv;
+
+ priv = gtk_file_chooser_dialog_get_instance_private (GTK_FILE_CHOOSER_DIALOG (object));
g_object_get_property (G_OBJECT (priv->widget), pspec->name, value);
}
gtk_file_chooser_dialog_map (GtkWidget *widget)
{
GtkFileChooserDialog *dialog = GTK_FILE_CHOOSER_DIALOG (widget);
- GtkFileChooserDialogPrivate *priv = GTK_FILE_CHOOSER_DIALOG_GET_PRIVATE (dialog);
+ GtkFileChooserDialogPrivate *priv = dialog->priv;
ensure_default_response (dialog);
{
GtkFileChooserDialogPrivate *priv;
- priv = GTK_FILE_CHOOSER_DIALOG_GET_PRIVATE (dialog);
+ priv = gtk_file_chooser_dialog_get_instance_private (GTK_FILE_CHOOSER_DIALOG (dialog));
/* Act only on response IDs we recognize */
if (is_stock_accept_response_id (response_id)
GtkWidget *impl;
};
-#define GTK_FILE_CHOOSER_WIDGET_GET_PRIVATE(o) (GTK_FILE_CHOOSER_WIDGET (o)->priv)
-
static GObject* gtk_file_chooser_widget_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_params);
GParamSpec *pspec);
G_DEFINE_TYPE_WITH_CODE (GtkFileChooserWidget, gtk_file_chooser_widget, GTK_TYPE_BOX,
+ G_ADD_PRIVATE (GtkFileChooserWidget)
G_IMPLEMENT_INTERFACE (GTK_TYPE_FILE_CHOOSER,
_gtk_file_chooser_delegate_iface_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_FILE_CHOOSER_EMBED,
gobject_class->get_property = gtk_file_chooser_widget_get_property;
_gtk_file_chooser_install_properties (gobject_class);
-
- g_type_class_add_private (class, sizeof (GtkFileChooserWidgetPrivate));
}
static void
-gtk_file_chooser_widget_init (GtkFileChooserWidget *chooser_widget)
+gtk_file_chooser_widget_init (GtkFileChooserWidget *self)
{
- GtkFileChooserWidgetPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (chooser_widget,
- GTK_TYPE_FILE_CHOOSER_WIDGET,
- GtkFileChooserWidgetPrivate);
- chooser_widget->priv = priv;
- gtk_orientable_set_orientation (GTK_ORIENTABLE (chooser_widget),
+ self->priv = gtk_file_chooser_widget_get_instance_private (self);
+
+ gtk_orientable_set_orientation (GTK_ORIENTABLE (self),
GTK_ORIENTATION_VERTICAL);
}
object = G_OBJECT_CLASS (gtk_file_chooser_widget_parent_class)->constructor (type,
n_construct_properties,
construct_params);
- priv = GTK_FILE_CHOOSER_WIDGET_GET_PRIVATE (object);
+ priv = gtk_file_chooser_widget_get_instance_private (GTK_FILE_CHOOSER_WIDGET (object));
priv->impl = _gtk_file_chooser_default_new ();
const GValue *value,
GParamSpec *pspec)
{
- GtkFileChooserWidgetPrivate *priv = GTK_FILE_CHOOSER_WIDGET_GET_PRIVATE (object);
+ GtkFileChooserWidgetPrivate *priv;
+
+ priv = gtk_file_chooser_widget_get_instance_private (GTK_FILE_CHOOSER_WIDGET (object));
switch (prop_id)
{
GValue *value,
GParamSpec *pspec)
{
- GtkFileChooserWidgetPrivate *priv = GTK_FILE_CHOOSER_WIDGET_GET_PRIVATE (object);
+ GtkFileChooserWidgetPrivate *priv;
+
+ priv = gtk_file_chooser_widget_get_instance_private (GTK_FILE_CHOOSER_WIDGET (object));
g_object_get_property (G_OBJECT (priv->impl), pspec->name, value);
}
gpointer data;
};
-G_DEFINE_TYPE (GtkFileSystem, _gtk_file_system, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkFileSystem, _gtk_file_system, G_TYPE_OBJECT)
/* GtkFileSystem methods */
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
- g_type_class_add_private (object_class, sizeof (GtkFileSystemPrivate));
}
static gboolean
DEBUG ("init");
- file_system->priv = G_TYPE_INSTANCE_GET_PRIVATE (file_system,
- GTK_TYPE_FILE_SYSTEM,
- GtkFileSystemPrivate);
- priv = file_system->priv;
+ file_system->priv = priv = _gtk_file_system_get_instance_private (file_system);
/* Volumes */
priv->volume_monitor = g_volume_monitor_get ();
GValue *value,
GParamSpec *pspec);
-G_DEFINE_TYPE (GtkFixed, gtk_fixed, GTK_TYPE_CONTAINER)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkFixed, gtk_fixed, GTK_TYPE_CONTAINER)
static void
gtk_fixed_class_init (GtkFixedClass *class)
P_("Y position of child widget"),
G_MININT, G_MAXINT, 0,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (class, sizeof (GtkFixedPrivate));
}
static GType
static void
gtk_fixed_init (GtkFixed *fixed)
{
- fixed->priv = G_TYPE_INSTANCE_GET_PRIVATE (fixed, GTK_TYPE_FIXED, GtkFixedPrivate);
+ fixed->priv = gtk_fixed_get_instance_private (fixed);
gtk_widget_set_has_window (GTK_WIDGET (fixed), FALSE);
}
G_DEFINE_TYPE_WITH_CODE (GtkFontButton, gtk_font_button, GTK_TYPE_BUTTON,
+ G_ADD_PRIVATE (GtkFontButton)
G_IMPLEMENT_INTERFACE (GTK_TYPE_FONT_CHOOSER,
gtk_font_button_font_chooser_iface_init))
gtk_widget_class_bind_child (widget_class, GtkFontButtonPrivate, font_label);
gtk_widget_class_bind_child (widget_class, GtkFontButtonPrivate, size_label);
gtk_widget_class_bind_child (widget_class, GtkFontButtonPrivate, font_size_box);
-
- g_type_class_add_private (gobject_class, sizeof (GtkFontButtonPrivate));
}
static void
gtk_font_button_init (GtkFontButton *font_button)
{
- font_button->priv = G_TYPE_INSTANCE_GET_PRIVATE (font_button,
- GTK_TYPE_FONT_BUTTON,
- GtkFontButtonPrivate);
+ font_button->priv = gtk_font_button_get_instance_private (font_button);
/* Initialize fields */
font_button->priv->use_font = FALSE;
const gchar *childname);
G_DEFINE_TYPE_WITH_CODE (GtkFontChooserDialog, gtk_font_chooser_dialog, GTK_TYPE_DIALOG,
+ G_ADD_PRIVATE (GtkFontChooserDialog)
G_IMPLEMENT_INTERFACE (GTK_TYPE_FONT_CHOOSER,
_gtk_font_chooser_delegate_iface_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_widget_class_bind_child (widget_class, GtkFontChooserDialogPrivate, select_button);
gtk_widget_class_bind_child (widget_class, GtkFontChooserDialogPrivate, cancel_button);
gtk_widget_class_bind_callback (widget_class, font_activated_cb);
-
- g_type_class_add_private (klass, sizeof (GtkFontChooserDialogPrivate));
}
static void
{
GtkFontChooserDialogPrivate *priv;
- fontchooserdiag->priv = G_TYPE_INSTANCE_GET_PRIVATE (fontchooserdiag,
- GTK_TYPE_FONT_CHOOSER_DIALOG,
- GtkFontChooserDialogPrivate);
+ fontchooserdiag->priv = gtk_font_chooser_dialog_get_instance_private (fontchooserdiag);
priv = fontchooserdiag->priv;
gtk_widget_init_template (GTK_WIDGET (fontchooserdiag));
static void gtk_font_chooser_widget_iface_init (GtkFontChooserIface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkFontChooserWidget, gtk_font_chooser_widget, GTK_TYPE_BOX,
+ G_ADD_PRIVATE (GtkFontChooserWidget)
G_IMPLEMENT_INTERFACE (GTK_TYPE_FONT_CHOOSER,
gtk_font_chooser_widget_iface_init))
gtk_widget_class_bind_callback (widget_class, row_inserted_cb);
gtk_widget_class_bind_callback (widget_class, row_deleted_cb);
gtk_widget_class_bind_callback (widget_class, size_change_cb);
-
- g_type_class_add_private (klass, sizeof (GtkFontChooserWidgetPrivate));
}
static void
{
GtkFontChooserWidgetPrivate *priv;
- fontchooser->priv = G_TYPE_INSTANCE_GET_PRIVATE (fontchooser,
- GTK_TYPE_FONT_CHOOSER_WIDGET,
- GtkFontChooserWidgetPrivate);
-
+ fontchooser->priv = gtk_font_chooser_widget_get_instance_private (fontchooser);
priv = fontchooser->priv;
gtk_widget_init_template (GTK_WIDGET (fontchooser));
G_DEFINE_TYPE_WITH_CODE (GtkFrame, gtk_frame, GTK_TYPE_BIN,
+ G_ADD_PRIVATE (GtkFrame)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_frame_buildable_init))
class->compute_child_allocation = gtk_frame_real_compute_child_allocation;
- g_type_class_add_private (class, sizeof (GtkFramePrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_FRAME_ACCESSIBLE);
}
GtkFramePrivate *priv;
GtkStyleContext *context;
- frame->priv = G_TYPE_INSTANCE_GET_PRIVATE (frame,
- GTK_TYPE_FRAME,
- GtkFramePrivate);
+ frame->priv = gtk_frame_get_instance_private (frame);
priv = frame->priv;
priv->label_widget = NULL;
};
G_DEFINE_TYPE_WITH_CODE (GtkGrid, gtk_grid, GTK_TYPE_CONTAINER,
+ G_ADD_PRIVATE (GtkGrid)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL))
{
GtkGridPrivate *priv;
- grid->priv = G_TYPE_INSTANCE_GET_PRIVATE (grid, GTK_TYPE_GRID, GtkGridPrivate);
+ grid->priv = gtk_grid_get_instance_private (grid);
priv = grid->priv;
gtk_widget_set_has_window (GTK_WIDGET (grid), FALSE);
P_("The number of rows that a child spans"),
1, G_MAXINT, 1,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (class, sizeof (GtkGridPrivate));
}
/**
static void gtk_header_bar_buildable_init (GtkBuildableIface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkHeaderBar, gtk_header_bar, GTK_TYPE_CONTAINER,
+ G_ADD_PRIVATE (GtkHeaderBar)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_header_bar_buildable_init));
static void
init_sizing_box (GtkHeaderBar *bar)
{
- GtkHeaderBarPrivate *priv = bar->priv;
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
GtkWidget *w;
/* We use this box to always request size for the two labels (title
static void
construct_label_box (GtkHeaderBar *bar)
{
- GtkHeaderBarPrivate *priv = bar->priv;
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
g_assert (priv->label_box == NULL);
GtkStyleContext *context;
GtkHeaderBarPrivate *priv;
- priv = G_TYPE_INSTANCE_GET_PRIVATE (bar, GTK_TYPE_HEADER_BAR, GtkHeaderBarPrivate);
- bar->priv = priv;
+ priv = gtk_header_bar_get_instance_private (bar);
gtk_widget_set_has_window (GTK_WIDGET (bar), FALSE);
gtk_widget_set_redraw_on_allocate (GTK_WIDGET (bar), FALSE);
static gint
count_visible_children (GtkHeaderBar *bar)
{
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
GList *l;
Child *child;
gint n;
n = 0;
- for (l = bar->priv->children; l; l = l->next)
+ for (l = priv->children; l; l = l->next)
{
child = l->data;
if (gtk_widget_get_visible (child->widget))
gint *natural_size)
{
GtkHeaderBar *bar = GTK_HEADER_BAR (widget);
- GtkHeaderBarPrivate *priv = bar->priv;
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
GList *l;
gint nvis_children;
gint minimum, natural;
gint *natural_size)
{
GtkHeaderBar *bar = GTK_HEADER_BAR (widget);
- GtkHeaderBarPrivate *priv = bar->priv;
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
GList *children;
gint required_size = 0;
gint required_natural = 0;
gint *natural_size)
{
GtkHeaderBar *bar = GTK_HEADER_BAR (widget);
- GtkHeaderBarPrivate *priv = bar->priv;
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
Child *child;
GList *children;
gint nvis_children;
GtkAllocation *allocation)
{
GtkHeaderBar *bar = GTK_HEADER_BAR (widget);
- GtkHeaderBarPrivate *priv = bar->priv;
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
GtkRequestedSize *sizes;
gint width, height;
gint nvis_children;
gtk_header_bar_set_title (GtkHeaderBar *bar,
const gchar *title)
{
- GtkHeaderBarPrivate *priv;
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
gchar *new_title;
g_return_if_fail (GTK_IS_HEADER_BAR (bar));
- priv = bar->priv;
-
new_title = g_strdup (title);
g_free (priv->title);
priv->title = new_title;
const gchar *
gtk_header_bar_get_title (GtkHeaderBar *bar)
{
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
+
g_return_val_if_fail (GTK_IS_HEADER_BAR (bar), NULL);
- return bar->priv->title;
+ return priv->title;
}
/**
gtk_header_bar_set_subtitle (GtkHeaderBar *bar,
const gchar *subtitle)
{
- GtkHeaderBarPrivate *priv;
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
gchar *new_subtitle;
g_return_if_fail (GTK_IS_HEADER_BAR (bar));
- priv = bar->priv;
-
new_subtitle = g_strdup (subtitle);
g_free (priv->subtitle);
priv->subtitle = new_subtitle;
const gchar *
gtk_header_bar_get_subtitle (GtkHeaderBar *bar)
{
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
+
g_return_val_if_fail (GTK_IS_HEADER_BAR (bar), NULL);
- return bar->priv->subtitle;
+ return priv->subtitle;
}
/**
gtk_header_bar_set_custom_title (GtkHeaderBar *bar,
GtkWidget *title_widget)
{
- GtkHeaderBarPrivate *priv;
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
g_return_if_fail (GTK_IS_HEADER_BAR (bar));
if (title_widget)
g_return_if_fail (GTK_IS_WIDGET (title_widget));
- priv = bar->priv;
-
/* No need to do anything if the custom widget stays the same */
if (priv->custom_title == title_widget)
return;
GtkWidget *
gtk_header_bar_get_custom_title (GtkHeaderBar *bar)
{
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
+
g_return_val_if_fail (GTK_IS_HEADER_BAR (bar), NULL);
- return bar->priv->custom_title;
+ return priv->custom_title;
}
static void
gtk_header_bar_finalize (GObject *object)
{
- GtkHeaderBar *bar = GTK_HEADER_BAR (object);
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (GTK_HEADER_BAR (object));
- g_free (bar->priv->title);
- g_free (bar->priv->subtitle);
+ g_free (priv->title);
+ g_free (priv->subtitle);
G_OBJECT_CLASS (gtk_header_bar_parent_class)->finalize (object);
}
GParamSpec *pspec)
{
GtkHeaderBar *bar = GTK_HEADER_BAR (object);
- GtkHeaderBarPrivate *priv = bar->priv;
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
switch (prop_id)
{
GParamSpec *pspec)
{
GtkHeaderBar *bar = GTK_HEADER_BAR (object);
- GtkHeaderBarPrivate *priv = bar->priv;
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
switch (prop_id)
{
GtkWidget *widget,
GtkPackType pack_type)
{
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
Child *child;
g_return_if_fail (gtk_widget_get_parent (widget) == NULL);
child->widget = widget;
child->pack_type = pack_type;
- bar->priv->children = g_list_append (bar->priv->children, child);
+ priv->children = g_list_append (priv->children, child);
gtk_widget_freeze_child_notify (widget);
gtk_widget_set_parent (widget, GTK_WIDGET (bar));
find_child_link (GtkHeaderBar *bar,
GtkWidget *widget)
{
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
GList *l;
Child *child;
- for (l = bar->priv->children; l; l = l->next)
+ for (l = priv->children; l; l = l->next)
{
child = l->data;
if (child->widget == widget)
GtkWidget *widget)
{
GtkHeaderBar *bar = GTK_HEADER_BAR (container);
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
GList *l;
Child *child;
{
child = l->data;
gtk_widget_unparent (child->widget);
- bar->priv->children = g_list_delete_link (bar->priv->children, l);
+ priv->children = g_list_delete_link (priv->children, l);
g_free (child);
gtk_widget_queue_resize (GTK_WIDGET (container));
}
gpointer callback_data)
{
GtkHeaderBar *bar = GTK_HEADER_BAR (container);
- GtkHeaderBarPrivate *priv = bar->priv;
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
Child *child;
GList *children;
GValue *value,
GParamSpec *pspec)
{
+ GtkHeaderBar *bar = GTK_HEADER_BAR (container);
+ GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
GList *l;
Child *child;
- l = find_child_link (GTK_HEADER_BAR (container), widget);
+ l = find_child_link (bar, widget);
if (l == NULL)
{
g_param_value_set_default (pspec, value);
break;
case CHILD_PROP_POSITION:
- g_value_set_int (value, g_list_position (GTK_HEADER_BAR (container)->priv->children, l));
+ g_value_set_int (value, g_list_position (priv->children, l));
break;
default:
DEFAULT_VPADDING,
GTK_PARAM_READWRITE));
- g_type_class_add_private (object_class, sizeof (GtkHeaderBarPrivate));
-
gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_FILLER);
}
struct _GtkHeaderBar
{
GtkContainer container;
-
- /*< private >*/
- GtkHeaderBarPrivate *priv;
};
struct _GtkHeaderBarClass
any_direction, any_state, any_size }
G_DEFINE_TYPE_WITH_CODE (GtkIconFactory, gtk_icon_factory, G_TYPE_OBJECT,
+ G_ADD_PRIVATE (GtkIconFactory)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_icon_factory_buildable_init))
{
GtkIconFactoryPrivate *priv;
- factory->priv = G_TYPE_INSTANCE_GET_PRIVATE (factory,
- GTK_TYPE_ICON_FACTORY,
- GtkIconFactoryPrivate);
+ factory->priv = gtk_icon_factory_get_instance_private (factory);
priv = factory->priv;
priv->icons = g_hash_table_new (g_str_hash, g_str_equal);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gtk_icon_factory_finalize;
-
- g_type_class_add_private (klass, sizeof (GtkIconFactoryPrivate));
}
static void
#include <math.h>
#include "gtkiconhelperprivate.h"
-G_DEFINE_TYPE (GtkIconHelper, _gtk_icon_helper, G_TYPE_OBJECT)
-
struct _GtkIconHelperPrivate {
GtkImageType storage_type;
gint last_surface_scale;
};
+G_DEFINE_TYPE_WITH_PRIVATE (GtkIconHelper, _gtk_icon_helper, G_TYPE_OBJECT)
+
void
_gtk_icon_helper_clear (GtkIconHelper *self)
{
oclass = G_OBJECT_CLASS (klass);
oclass->finalize = gtk_icon_helper_finalize;
-
- g_type_class_add_private (klass, sizeof (GtkIconHelperPrivate));
}
static void
_gtk_icon_helper_init (GtkIconHelper *self)
{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GTK_TYPE_ICON_HELPER, GtkIconHelperPrivate);
+ self->priv = _gtk_icon_helper_get_instance_private (self);
self->priv->storage_type = GTK_IMAGE_EMPTY;
self->priv->icon_size = GTK_ICON_SIZE_INVALID;
return a->icon_names[i] == NULL && b->icon_names[i] == NULL;
}
-G_DEFINE_TYPE (GtkIconTheme, gtk_icon_theme, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkIconTheme, gtk_icon_theme, G_TYPE_OBJECT)
/**
* gtk_icon_theme_new:
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
- g_type_class_add_private (klass, sizeof (GtkIconThemePrivate));
}
const gchar * const *xdg_data_dirs;
int i, j;
- priv = G_TYPE_INSTANCE_GET_PRIVATE (icon_theme,
- GTK_TYPE_ICON_THEME,
- GtkIconThemePrivate);
+ priv = gtk_icon_theme_get_instance_private (icon_theme);
icon_theme->priv = priv;
priv->info_cache = g_hash_table_new_full (icon_info_key_hash, icon_info_key_equal, NULL,
static guint icon_view_signals[LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE_WITH_CODE (GtkIconView, gtk_icon_view, GTK_TYPE_CONTAINER,
+ G_ADD_PRIVATE (GtkIconView)
G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
gtk_icon_view_cell_layout_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
binding_set = gtk_binding_set_by_class (klass);
- g_type_class_add_private (klass, sizeof (GtkIconViewPrivate));
-
gobject_class = (GObjectClass *) klass;
widget_class = (GtkWidgetClass *) klass;
container_class = (GtkContainerClass *) klass;
static void
gtk_icon_view_init (GtkIconView *icon_view)
{
- icon_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (icon_view,
- GTK_TYPE_ICON_VIEW,
- GtkIconViewPrivate);
+ icon_view->priv = gtk_icon_view_get_instance_private (icon_view);
icon_view->priv->width = 0;
icon_view->priv->height = 0;
PROP_USE_FALLBACK
};
-G_DEFINE_TYPE (GtkImage, gtk_image, GTK_TYPE_MISC)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkImage, gtk_image, GTK_TYPE_MISC)
static void
gtk_image_class_init (GtkImageClass *class)
FALSE,
GTK_PARAM_READWRITE));
- g_type_class_add_private (class, sizeof (GtkImagePrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_IMAGE_ACCESSIBLE);
}
{
GtkImagePrivate *priv;
- image->priv = G_TYPE_INSTANCE_GET_PRIVATE (image,
- GTK_TYPE_IMAGE,
- GtkImagePrivate);
+ image->priv = gtk_image_get_instance_private (image);
priv = image->priv;
gtk_widget_set_has_window (GTK_WIDGET (image), FALSE);
G_DEFINE_TYPE_WITH_CODE (GtkImageMenuItem, gtk_image_menu_item, GTK_TYPE_MENU_ITEM,
+ G_ADD_PRIVATE (GtkImageMenuItem)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,
gtk_image_menu_item_activatable_interface_init))
GTK_TYPE_ACCEL_GROUP,
GTK_PARAM_WRITABLE | G_PARAM_DEPRECATED));
- g_type_class_add_private (klass, sizeof (GtkImageMenuItemPrivate));
}
static void
{
GtkImageMenuItemPrivate *priv;
- image_menu_item->priv = G_TYPE_INSTANCE_GET_PRIVATE (image_menu_item,
- GTK_TYPE_IMAGE_MENU_ITEM,
- GtkImageMenuItemPrivate);
+ image_menu_item->priv = gtk_image_menu_item_get_instance_private (image_menu_item);
priv = image_menu_item->priv;
priv->image = NULL;
GParamSpec *pspec);
-G_DEFINE_ABSTRACT_TYPE (GtkIMContext, gtk_im_context, G_TYPE_OBJECT)
+G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GtkIMContext, gtk_im_context, G_TYPE_OBJECT)
/**
* GtkIMContextClass:
GTK_INPUT_HINT_NONE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
- g_type_class_add_private (klass, sizeof (GtkIMContextPrivate));
g_object_class_install_properties (object_class, LAST_PROPERTY, properties);
}
GValue *value,
GParamSpec *pspec)
{
- GtkIMContextPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (obj, GTK_TYPE_IM_CONTEXT, GtkIMContextPrivate);
+ GtkIMContextPrivate *priv = gtk_im_context_get_instance_private (GTK_IM_CONTEXT (obj));
switch (property_id)
{
const GValue *value,
GParamSpec *pspec)
{
- GtkIMContextPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (obj, GTK_TYPE_IM_CONTEXT, GtkIMContextPrivate);
+ GtkIMContextPrivate *priv = gtk_im_context_get_instance_private (GTK_IM_CONTEXT (obj));
switch (property_id)
{
PangoAttrList **attrs,
gint *cursor_pos);
-G_DEFINE_TYPE (GtkIMContextSimple, gtk_im_context_simple, GTK_TYPE_IM_CONTEXT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkIMContextSimple, gtk_im_context_simple, GTK_TYPE_IM_CONTEXT)
static void
gtk_im_context_simple_class_init (GtkIMContextSimpleClass *class)
im_context_class->reset = gtk_im_context_simple_reset;
im_context_class->get_preedit_string = gtk_im_context_simple_get_preedit_string;
gobject_class->finalize = gtk_im_context_simple_finalize;
-
- g_type_class_add_private (class, sizeof (GtkIMContextSimplePrivate));
}
static void
gtk_im_context_simple_init (GtkIMContextSimple *im_context_simple)
{
- im_context_simple->priv = G_TYPE_INSTANCE_GET_PRIVATE (im_context_simple,
- GTK_TYPE_IM_CONTEXT_SIMPLE,
- GtkIMContextSimplePrivate);
+ im_context_simple->priv = gtk_im_context_simple_get_instance_private (im_context_simple);
}
static void
static const gchar *global_context_id = NULL;
-G_DEFINE_TYPE (GtkIMMulticontext, gtk_im_multicontext, GTK_TYPE_IM_CONTEXT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkIMMulticontext, gtk_im_multicontext, GTK_TYPE_IM_CONTEXT)
static void
gtk_im_multicontext_class_init (GtkIMMulticontextClass *class)
im_context_class->get_surrounding = gtk_im_multicontext_get_surrounding;
gobject_class->finalize = gtk_im_multicontext_finalize;
-
- g_type_class_add_private (gobject_class, sizeof (GtkIMMulticontextPrivate));
}
static void
{
GtkIMMulticontextPrivate *priv;
- multicontext->priv = G_TYPE_INSTANCE_GET_PRIVATE (multicontext, GTK_TYPE_IM_MULTICONTEXT, GtkIMMulticontextPrivate);
+ multicontext->priv = gtk_im_multicontext_get_instance_private (multicontext);
priv = multicontext->priv;
priv->slave = NULL;
G_DEFINE_TYPE_WITH_CODE (GtkInfoBar, gtk_info_bar, GTK_TYPE_BOX,
+ G_ADD_PRIVATE (GtkInfoBar)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_info_bar_buildable_interface_init))
gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/libgtk/gtkinfobar.ui");
gtk_widget_class_bind_child_internal (widget_class, GtkInfoBarPrivate, content_area);
gtk_widget_class_bind_child_internal (widget_class, GtkInfoBarPrivate, action_area);
-
- g_type_class_add_private (object_class, sizeof (GtkInfoBarPrivate));
}
static void
{
GtkWidget *widget = GTK_WIDGET (info_bar);
- info_bar->priv = G_TYPE_INSTANCE_GET_PRIVATE (info_bar,
- GTK_TYPE_INFO_BAR,
- GtkInfoBarPrivate);
+ info_bar->priv = gtk_info_bar_get_instance_private (info_bar);
gtk_widget_set_redraw_on_allocate (widget, TRUE);
guint n_construct_properties,
GObjectConstructParam *construct_params);
-G_DEFINE_TYPE (GtkInvisible, gtk_invisible, GTK_TYPE_WIDGET)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkInvisible, gtk_invisible, GTK_TYPE_WIDGET)
static void
gtk_invisible_class_init (GtkInvisibleClass *class)
P_("The screen where this window will be displayed"),
GDK_TYPE_SCREEN,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (class, sizeof (GtkInvisiblePrivate));
}
static void
{
GtkInvisiblePrivate *priv;
- invisible->priv = G_TYPE_INSTANCE_GET_PRIVATE (invisible,
- GTK_TYPE_INVISIBLE,
- GtkInvisiblePrivate);
+ invisible->priv = gtk_invisible_get_instance_private (invisible);
priv = invisible->priv;
gtk_widget_set_has_window (GTK_WIDGET (invisible), TRUE);
static GtkBuildableIface *buildable_parent_iface = NULL;
G_DEFINE_TYPE_WITH_CODE (GtkLabel, gtk_label, GTK_TYPE_MISC,
+ G_ADD_PRIVATE (GtkLabel)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_label_buildable_interface_init))
gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Enter, 0,
"activate-current-link", 0);
- g_type_class_add_private (class, sizeof (GtkLabelPrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_LABEL_ACCESSIBLE);
}
{
GtkLabelPrivate *priv;
- label->priv = G_TYPE_INSTANCE_GET_PRIVATE (label,
- GTK_TYPE_LABEL,
- GtkLabelPrivate);
+ label->priv = gtk_label_get_instance_private (label);
priv = label->priv;
gtk_widget_set_has_window (GTK_WIDGET (label), FALSE);
static void gtk_layout_set_vadjustment_values (GtkLayout *layout);
G_DEFINE_TYPE_WITH_CODE (GtkLayout, gtk_layout, GTK_TYPE_CONTAINER,
+ G_ADD_PRIVATE (GtkLayout)
G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
/* Public interface
container_class->add = gtk_layout_add;
container_class->remove = gtk_layout_remove;
container_class->forall = gtk_layout_forall;
-
- g_type_class_add_private (class, sizeof (GtkLayoutPrivate));
}
static void
{
GtkLayoutPrivate *priv;
- layout->priv = G_TYPE_INSTANCE_GET_PRIVATE (layout,
- GTK_TYPE_LAYOUT,
- GtkLayoutPrivate);
+ layout->priv = gtk_layout_get_instance_private (layout);
priv = layout->priv;
priv->children = NULL;
#define STYLE_CLASS_FILL_BLOCK "fill-block"
#define STYLE_CLASS_EMPTY_FILL_BLOCK "empty-fill-block"
-static void gtk_level_bar_buildable_init (GtkBuildableIface *iface);
-
-G_DEFINE_TYPE_WITH_CODE (GtkLevelBar, gtk_level_bar, GTK_TYPE_WIDGET,
- G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL)
- G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
- gtk_level_bar_buildable_init))
-
enum {
PROP_VALUE = 1,
PROP_MIN_VALUE,
static void gtk_level_bar_set_value_internal (GtkLevelBar *self,
gdouble value);
+static void gtk_level_bar_buildable_init (GtkBuildableIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (GtkLevelBar, gtk_level_bar, GTK_TYPE_WIDGET,
+ G_ADD_PRIVATE (GtkLevelBar)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
+ gtk_level_bar_buildable_init))
+
static GtkLevelBarOffset *
gtk_level_bar_offset_new (const gchar *name,
gdouble value)
1, G_MAXINT, DEFAULT_BLOCK_SIZE,
G_PARAM_READWRITE));
- g_type_class_add_private (klass, sizeof (GtkLevelBarPrivate));
g_object_class_install_properties (oclass, LAST_PROPERTY, properties);
gtk_widget_class_set_accessible_type (wclass, GTK_TYPE_LEVEL_BAR_ACCESSIBLE);
{
GtkStyleContext *context;
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GTK_TYPE_LEVEL_BAR, GtkLevelBarPrivate);
+ self->priv = gtk_level_bar_get_instance_private (self);
context = gtk_widget_get_style_context (GTK_WIDGET (self));
gtk_style_context_add_class (context, GTK_STYLE_CLASS_LEVEL_BAR);
static guint link_signals[LAST_SIGNAL] = { 0, };
-G_DEFINE_TYPE (GtkLinkButton, gtk_link_button, GTK_TYPE_BUTTON)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkLinkButton, gtk_link_button, GTK_TYPE_BUTTON)
static void
gtk_link_button_class_init (GtkLinkButtonClass *klass)
P_("Whether this link has been visited."),
FALSE,
G_PARAM_READWRITE));
-
- g_type_class_add_private (gobject_class, sizeof (GtkLinkButtonPrivate));
/**
* GtkLinkButton::activate-link:
static void
gtk_link_button_init (GtkLinkButton *link_button)
{
- link_button->priv = G_TYPE_INSTANCE_GET_PRIVATE (link_button,
- GTK_TYPE_LINK_BUTTON,
- GtkLinkButtonPrivate);
+ link_button->priv = gtk_link_button_get_instance_private (link_button);
gtk_button_set_relief (GTK_BUTTON (link_button), GTK_RELIEF_NONE);
gpointer *data);
G_DEFINE_TYPE_WITH_CODE (GtkListStore, gtk_list_store, G_TYPE_OBJECT,
+ G_ADD_PRIVATE (GtkListStore)
G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
gtk_list_store_tree_model_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE,
object_class = (GObjectClass*) class;
object_class->finalize = gtk_list_store_finalize;
-
- g_type_class_add_private (class, sizeof (GtkListStorePrivate));
}
static void
{
GtkListStorePrivate *priv;
- list_store->priv = G_TYPE_INSTANCE_GET_PRIVATE (list_store,
- GTK_TYPE_LIST_STORE,
- GtkListStorePrivate);
+ list_store->priv = gtk_list_store_get_instance_private (list_store);
priv = list_store->priv;
priv->seq = g_sequence_new (NULL);
GParamSpec *pspec,
gpointer user_data);
-G_DEFINE_TYPE (GtkLockButton, gtk_lock_button, GTK_TYPE_BUTTON);
+G_DEFINE_TYPE_WITH_PRIVATE (GtkLockButton, gtk_lock_button, GTK_TYPE_BUTTON)
static void
gtk_lock_button_finalize (GObject *object)
GtkLockButtonPrivate *priv;
gchar *names[3];
- button->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (button,
- GTK_TYPE_LOCK_BUTTON,
- GtkLockButtonPrivate);
+ button->priv = priv = gtk_lock_button_get_instance_private (button);
gtk_widget_init_template (GTK_WIDGET (button));
button_class->clicked = gtk_lock_button_clicked;
- g_type_class_add_private (klass, sizeof (GtkLockButtonPrivate));
-
g_object_class_install_property (gobject_class, PROP_PERMISSION,
g_param_spec_object ("permission",
P_("Permission"),
static guint menu_signals[LAST_SIGNAL] = { 0 };
-G_DEFINE_TYPE (GtkMenu, gtk_menu, GTK_TYPE_MENU_SHELL)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkMenu, gtk_menu, GTK_TYPE_MENU_SHELL)
static void
menu_queue_resize (GtkMenu *menu)
GTK_TYPE_SCROLL_TYPE,
GTK_SCROLL_PAGE_DOWN);
- g_type_class_add_private (gobject_class, sizeof (GtkMenuPrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_MENU_ACCESSIBLE);
}
GtkMenuPrivate *priv;
GtkStyleContext *context;
- priv = G_TYPE_INSTANCE_GET_PRIVATE (menu, GTK_TYPE_MENU, GtkMenuPrivate);
+ priv = gtk_menu_get_instance_private (menu);
menu->priv = priv;
static GtkShadowType get_shadow_type (GtkMenuBar *menubar);
-G_DEFINE_TYPE (GtkMenuBar, gtk_menu_bar, GTK_TYPE_MENU_SHELL)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkMenuBar, gtk_menu_bar, GTK_TYPE_MENU_SHELL)
static void
gtk_menu_bar_class_init (GtkMenuBarClass *class)
0,
GTK_PARAM_READABLE |
G_PARAM_DEPRECATED));
-
- g_type_class_add_private (gobject_class, sizeof (GtkMenuBarPrivate));
}
static void
{
GtkStyleContext *context;
- menu_bar->priv = G_TYPE_INSTANCE_GET_PRIVATE (menu_bar,
- GTK_TYPE_MENU_BAR,
- GtkMenuBarPrivate);
+ menu_bar->priv = gtk_menu_bar_get_instance_private (menu_bar);
context = gtk_widget_get_style_context (GTK_WIDGET (menu_bar));
gtk_style_context_add_class (context, GTK_STYLE_CLASS_MENUBAR);
PROP_DIRECTION
};
-G_DEFINE_TYPE(GtkMenuButton, gtk_menu_button, GTK_TYPE_TOGGLE_BUTTON)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkMenuButton, gtk_menu_button, GTK_TYPE_TOGGLE_BUTTON)
static void gtk_menu_button_dispose (GObject *object);
GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
GtkToggleButtonClass *toggle_button_class = GTK_TOGGLE_BUTTON_CLASS (klass);
- g_type_class_add_private (klass, sizeof (GtkMenuButtonPrivate));
-
gobject_class->set_property = gtk_menu_button_set_property;
gobject_class->get_property = gtk_menu_button_get_property;
gobject_class->dispose = gtk_menu_button_dispose;
{
GtkMenuButtonPrivate *priv;
- priv = G_TYPE_INSTANCE_GET_PRIVATE (menu_button, GTK_TYPE_MENU_BUTTON, GtkMenuButtonPrivate);
+ priv = gtk_menu_button_get_instance_private (menu_button);
menu_button->priv = priv;
priv->arrow_type = GTK_ARROW_DOWN;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
G_DEFINE_TYPE_WITH_CODE (GtkMenuItem, gtk_menu_item, GTK_TYPE_BIN,
+ G_ADD_PRIVATE (GtkMenuItem)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_menu_item_buildable_interface_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,
P_("The minimum desired width of the menu item in characters"),
0, G_MAXINT, 12,
GTK_PARAM_READABLE));
-
- g_type_class_add_private (klass, sizeof (GtkMenuItemPrivate));
}
static void
GtkStyleContext *context;
GtkMenuItemPrivate *priv;
- priv = G_TYPE_INSTANCE_GET_PRIVATE (menu_item,
- GTK_TYPE_MENU_ITEM,
- GtkMenuItemPrivate);
+ priv = gtk_menu_item_get_instance_private (menu_item);
menu_item->priv = priv;
gtk_widget_set_has_window (GTK_WIDGET (menu_item), FALSE);
static guint menu_shell_signals[LAST_SIGNAL] = { 0 };
-G_DEFINE_ABSTRACT_TYPE (GtkMenuShell, gtk_menu_shell, GTK_TYPE_CONTAINER)
+G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GtkMenuShell, gtk_menu_shell, GTK_TYPE_CONTAINER)
static void
gtk_menu_shell_class_init (GtkMenuShellClass *klass)
GTK_PARAM_READWRITE));
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_MENU_SHELL_ACCESSIBLE);
-
- g_type_class_add_private (object_class, sizeof (GtkMenuShellPrivate));
}
static GType
static void
gtk_menu_shell_init (GtkMenuShell *menu_shell)
{
- GtkMenuShellPrivate *priv;
-
- priv = G_TYPE_INSTANCE_GET_PRIVATE (menu_shell,
- GTK_TYPE_MENU_SHELL,
- GtkMenuShellPrivate);
- menu_shell->priv = priv;
- priv->take_focus = TRUE;
+ menu_shell->priv = gtk_menu_shell_get_instance_private (menu_shell);
+ menu_shell->priv->take_focus = TRUE;
}
static void
static GtkBuildableIface *parent_buildable_iface;
G_DEFINE_TYPE_WITH_CODE (GtkMenuToolButton, gtk_menu_tool_button, GTK_TYPE_TOOL_BUTTON,
+ G_ADD_PRIVATE (GtkMenuToolButton)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_menu_tool_button_buildable_interface_init))
P_("The dropdown menu"),
GTK_TYPE_MENU,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (object_class, sizeof (GtkMenuToolButtonPrivate));
}
static void
GtkWidget *arrow_button;
GtkWidget *real_button;
- button->priv = G_TYPE_INSTANCE_GET_PRIVATE (button,
- GTK_TYPE_MENU_TOOL_BUTTON,
- GtkMenuToolButtonPrivate);
+ button->priv = gtk_menu_tool_button_get_instance_private (button);
gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (button), FALSE);
};
G_DEFINE_TYPE_WITH_CODE (GtkMessageDialog, gtk_message_dialog, GTK_TYPE_DIALOG,
+ G_ADD_PRIVATE (GtkMessageDialog)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_message_dialog_buildable_interface_init))
gtk_widget_class_bind_child (widget_class, GtkMessageDialogPrivate, label);
gtk_widget_class_bind_child (widget_class, GtkMessageDialogPrivate, secondary_label);
gtk_widget_class_bind_child_internal (widget_class, GtkMessageDialogPrivate, message_area);
-
- g_type_class_add_private (gobject_class, sizeof (GtkMessageDialogPrivate));
}
static void
{
GtkMessageDialogPrivate *priv;
- dialog->priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog,
- GTK_TYPE_MESSAGE_DIALOG,
- GtkMessageDialogPrivate);
+ dialog->priv = gtk_message_dialog_get_instance_private (dialog);
priv = dialog->priv;
priv->has_primary_markup = FALSE;
GParamSpec *pspec);
-G_DEFINE_ABSTRACT_TYPE (GtkMisc, gtk_misc, GTK_TYPE_WIDGET)
+G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GtkMisc, gtk_misc, GTK_TYPE_WIDGET)
static void
gtk_misc_class_init (GtkMiscClass *class)
G_MAXINT,
0,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (class, sizeof (GtkMiscPrivate));
}
static void
{
GtkMiscPrivate *priv;
- misc->priv = G_TYPE_INSTANCE_GET_PRIVATE (misc,
- GTK_TYPE_MISC,
- GtkMiscPrivate);
+ misc->priv = gtk_misc_get_instance_private (misc);
priv = misc->priv;
priv->xalign = 0.5;
static void gtk_modifier_style_finalize (GObject *object);
G_DEFINE_TYPE_EXTENDED (GtkModifierStyle, _gtk_modifier_style, G_TYPE_OBJECT, 0,
+ G_ADD_PRIVATE (GtkModifierStyle)
G_IMPLEMENT_INTERFACE (GTK_TYPE_STYLE_PROVIDER,
gtk_modifier_style_provider_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_STYLE_PROVIDER_PRIVATE,
0, NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
- g_type_class_add_private (object_class, sizeof (GtkModifierStylePrivate));
}
static void
{
GtkModifierStylePrivate *priv;
- priv = modifier_style->priv = G_TYPE_INSTANCE_GET_PRIVATE (modifier_style,
- GTK_TYPE_MODIFIER_STYLE,
- GtkModifierStylePrivate);
+ priv = modifier_style->priv = _gtk_modifier_style_get_instance_private (modifier_style);
priv->color_properties = g_hash_table_new_full (g_str_hash,
g_str_equal,
static void gtk_mount_operation_aborted (GMountOperation *op);
-G_DEFINE_TYPE (GtkMountOperation, gtk_mount_operation, G_TYPE_MOUNT_OPERATION);
-
-enum {
- PROP_0,
- PROP_PARENT,
- PROP_IS_SHOWING,
- PROP_SCREEN
-
-};
-
struct _GtkMountOperationPrivate {
GtkWindow *parent_window;
GtkDialog *dialog;
GtkListStore *process_list_store;
};
+enum {
+ PROP_0,
+ PROP_PARENT,
+ PROP_IS_SHOWING,
+ PROP_SCREEN
+
+};
+
+G_DEFINE_TYPE_WITH_PRIVATE (GtkMountOperation, gtk_mount_operation, G_TYPE_MOUNT_OPERATION)
+
static void
gtk_mount_operation_class_init (GtkMountOperationClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GMountOperationClass *mount_op_class = G_MOUNT_OPERATION_CLASS (klass);
- g_type_class_add_private (klass, sizeof (GtkMountOperationPrivate));
-
object_class->finalize = gtk_mount_operation_finalize;
object_class->get_property = gtk_mount_operation_get_property;
object_class->set_property = gtk_mount_operation_set_property;
{
gchar *name_owner;
- operation->priv = G_TYPE_INSTANCE_GET_PRIVATE (operation,
- GTK_TYPE_MOUNT_OPERATION,
- GtkMountOperationPrivate);
+ operation->priv = gtk_mount_operation_get_instance_private (operation);
operation->priv->handler =
_gtk_mount_operation_handler_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
static guint notebook_signals[LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE_WITH_CODE (GtkNotebook, gtk_notebook, GTK_TYPE_CONTAINER,
+ G_ADD_PRIVATE (GtkNotebook)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_notebook_buildable_init))
add_tab_bindings (binding_set, GDK_CONTROL_MASK, GTK_DIR_TAB_FORWARD);
add_tab_bindings (binding_set, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
- g_type_class_add_private (class, sizeof (GtkNotebookPrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_NOTEBOOK_ACCESSIBLE);
}
gtk_widget_set_can_focus (GTK_WIDGET (notebook), TRUE);
gtk_widget_set_has_window (GTK_WIDGET (notebook), FALSE);
- notebook->priv = G_TYPE_INSTANCE_GET_PRIVATE (notebook,
- GTK_TYPE_NOTEBOOK,
- GtkNotebookPrivate);
+ notebook->priv = gtk_notebook_get_instance_private (notebook);
priv = notebook->priv;
priv->cur_page = NULL;
static GParamSpec *properties[NUM_PROPERTIES] = { NULL, };
-G_DEFINE_TYPE (GtkNumerableIcon, gtk_numerable_icon, G_TYPE_EMBLEMED_ICON);
+G_DEFINE_TYPE_WITH_PRIVATE (GtkNumerableIcon, gtk_numerable_icon, G_TYPE_EMBLEMED_ICON)
static gint
get_surface_size (cairo_surface_t *surface)
oclass->dispose = gtk_numerable_icon_dispose;
oclass->finalize = gtk_numerable_icon_finalize;
- g_type_class_add_private (klass, sizeof (GtkNumerableIconPrivate));
-
properties[PROP_COUNT] =
g_param_spec_int ("count",
P_("Icon's count"),
GdkRGBA bg;
GdkRGBA fg;
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
- GTK_TYPE_NUMERABLE_ICON,
- GtkNumerableIconPrivate);
+ self->priv = gtk_numerable_icon_get_instance_private (self);
gdk_rgba_parse (&bg, DEFAULT_BACKGROUND);
gdk_rgba_parse (&fg, DEFAULT_FOREGROUND);
static void gtk_overlay_buildable_init (GtkBuildableIface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkOverlay, gtk_overlay, GTK_TYPE_BIN,
+ G_ADD_PRIVATE (GtkOverlay)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_overlay_buildable_init))
G_TYPE_BOOLEAN, 2,
GTK_TYPE_WIDGET,
GDK_TYPE_RECTANGLE | G_SIGNAL_TYPE_STATIC_SCOPE);
-
- g_type_class_add_private (object_class, sizeof (GtkOverlayPrivate));
}
static void
gtk_overlay_init (GtkOverlay *overlay)
{
- overlay->priv = G_TYPE_INSTANCE_GET_PRIVATE (overlay, GTK_TYPE_OVERLAY, GtkOverlayPrivate);
+ overlay->priv = gtk_overlay_get_instance_private (overlay);
gtk_widget_set_has_window (GTK_WIDGET (overlay), FALSE);
}
PAGE_SETUP_LIST_N_COLS
};
-G_DEFINE_TYPE (GtkPageSetupUnixDialog, gtk_page_setup_unix_dialog, GTK_TYPE_DIALOG)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkPageSetupUnixDialog, gtk_page_setup_unix_dialog, GTK_TYPE_DIALOG)
static void gtk_page_setup_unix_dialog_finalize (GObject *object);
static void fill_paper_sizes_from_printer (GtkPageSetupUnixDialog *dialog,
gtk_widget_class_bind_callback (widget_class, printer_changed_callback);
gtk_widget_class_bind_callback (widget_class, paper_size_changed);
-
- g_type_class_add_private (class, sizeof (GtkPageSetupUnixDialogPrivate));
}
static void
GtkTreeIter iter;
gchar *tmp;
- priv = dialog->priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog,
- GTK_TYPE_PAGE_SETUP_UNIX_DIALOG,
- GtkPageSetupUnixDialogPrivate);
+ priv = dialog->priv = gtk_page_setup_unix_dialog_get_instance_private (dialog);
priv->print_backends = NULL;
G_DEFINE_TYPE_WITH_CODE (GtkPaned, gtk_paned, GTK_TYPE_CONTAINER,
+ G_ADD_PRIVATE (GtkPaned)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE,
NULL))
add_move_binding (binding_set, GDK_KEY_End, 0, GTK_SCROLL_END);
add_move_binding (binding_set, GDK_KEY_KP_End, 0, GTK_SCROLL_END);
- g_type_class_add_private (object_class, sizeof (GtkPanedPrivate));
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_PANED_ACCESSIBLE);
}
*/
gtk_widget_set_redraw_on_allocate (GTK_WIDGET (paned), FALSE);
- paned->priv = G_TYPE_INSTANCE_GET_PRIVATE (paned, GTK_TYPE_PANED, GtkPanedPrivate);
+ paned->priv = gtk_paned_get_instance_private (paned);
priv = paned->priv;
priv->orientation = GTK_ORIENTATION_HORIZONTAL;
*/
#define BUTTON_IS_FAKE_ROOT(button) ((button)->type == HOME_BUTTON)
-G_DEFINE_TYPE (GtkPathBar, gtk_path_bar, GTK_TYPE_CONTAINER)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkPathBar, gtk_path_bar, GTK_TYPE_CONTAINER)
static void gtk_path_bar_finalize (GObject *object);
static void gtk_path_bar_dispose (GObject *object);
static void
gtk_path_bar_init (GtkPathBar *path_bar)
{
- path_bar->priv = G_TYPE_INSTANCE_GET_PRIVATE (path_bar,
- GTK_TYPE_PATH_BAR,
- GtkPathBarPrivate);
+ path_bar->priv = gtk_path_bar_get_instance_private (path_bar);
gtk_widget_init_template (GTK_WIDGET (path_bar));
gtk_widget_class_bind_callback (widget_class, gtk_path_bar_scroll_up);
gtk_widget_class_bind_callback (widget_class, gtk_path_bar_scroll_down);
gtk_widget_class_bind_callback (widget_class, on_slider_unmap);
-
- g_type_class_add_private (gobject_class, sizeof (GtkPathBarPrivate));
}
static guint plug_signals[LAST_SIGNAL] = { 0 };
-G_DEFINE_TYPE (GtkPlug, gtk_plug, GTK_TYPE_WINDOW)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkPlug, gtk_plug, GTK_TYPE_WINDOW)
static void
gtk_plug_get_property (GObject *object,
NULL, NULL,
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
- g_type_class_add_private (class, sizeof (GtkPlugPrivate));
}
static void
gtk_plug_init (GtkPlug *plug)
{
- plug->priv = G_TYPE_INSTANCE_GET_PRIVATE (plug,
- GTK_TYPE_PLUG,
- GtkPlugPrivate);
+ plug->priv = gtk_plug_get_instance_private (plug);
}
/**
static guint signals[LAST_SIGNAL];
-G_DEFINE_TYPE (GtkPressAndHold, gtk_press_and_hold, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkPressAndHold, gtk_press_and_hold, G_TYPE_OBJECT)
static void
gtk_press_and_hold_init (GtkPressAndHold *pah)
{
- pah->priv = G_TYPE_INSTANCE_GET_PRIVATE (pah,
- GTK_TYPE_PRESS_AND_HOLD,
- GtkPressAndHoldPrivate);
-
+ pah->priv = gtk_press_and_hold_get_instance_private (pah);
pah->priv->hold_time = 1000;
pah->priv->drag_threshold = 8;
}
g_object_class_install_property (object_class, PROP_DRAG_THRESHOLD,
g_param_spec_int ("drag-threshold", P_("Drag Threshold"), P_("Drag Threshold (in pixels)"),
1, G_MAXINT, 8, GTK_PARAM_READWRITE));
-
- g_type_class_add_private (object_class, sizeof (GtkPressAndHoldPrivate));
}
static void
* GtkPrintBackend *
*****************************************/
-G_DEFINE_TYPE (GtkPrintBackend, gtk_print_backend, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkPrintBackend, gtk_print_backend, G_TYPE_OBJECT)
static void fallback_printer_request_details (GtkPrinter *printer);
static gboolean fallback_printer_mark_conflicts (GtkPrinter *printer,
GTK_PRINT_BACKEND_STATUS_UNAVAILABLE,
GTK_PRINT_BACKEND_STATUS_UNKNOWN,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (class, sizeof (GtkPrintBackendPrivate));
signals[PRINTER_LIST_CHANGED] =
g_signal_new (I_("printer-list-changed"),
{
GtkPrintBackendPrivate *priv;
- priv = backend->priv = G_TYPE_INSTANCE_GET_PRIVATE (backend,
- GTK_TYPE_PRINT_BACKEND,
- GtkPrintBackendPrivate);
+ priv = backend->priv = gtk_print_backend_get_instance_private (backend);
priv->printers = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify) g_free,
GValue *value,
GParamSpec *pspec);
-G_DEFINE_TYPE (GtkPrinter, gtk_printer, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkPrinter, gtk_printer, G_TYPE_OBJECT)
static void
gtk_printer_class_init (GtkPrinterClass *class)
object_class->set_property = gtk_printer_set_property;
object_class->get_property = gtk_printer_get_property;
- g_type_class_add_private (class, sizeof (GtkPrinterPrivate));
-
g_object_class_install_property (G_OBJECT_CLASS (class),
PROP_NAME,
g_param_spec_string ("name",
{
GtkPrinterPrivate *priv;
- priv = printer->priv = G_TYPE_INSTANCE_GET_PRIVATE (printer,
- GTK_TYPE_PRINTER,
- GtkPrinterPrivate);
+ priv = printer->priv = gtk_printer_get_instance_private (printer);
priv->name = NULL;
priv->location = NULL;
#include "gtkprinteroptionwidget.h"
-#define GTK_PRINTER_OPTION_WIDGET_GET_PRIVATE(o) \
- (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_PRINTER_OPTION_WIDGET, GtkPrinterOptionWidgetPrivate))
-
/* This defines the max file length that the file chooser
* button should display. The total length will be
* FILENAME_LENGTH_MAX+3 because the truncated name is prefixed
static guint signals[LAST_SIGNAL] = { 0 };
-G_DEFINE_TYPE (GtkPrinterOptionWidget, gtk_printer_option_widget, GTK_TYPE_BOX)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkPrinterOptionWidget, gtk_printer_option_widget, GTK_TYPE_BOX)
static void gtk_printer_option_widget_set_property (GObject *object,
guint prop_id,
widget_class->mnemonic_activate = gtk_printer_option_widget_mnemonic_activate;
- g_type_class_add_private (class, sizeof (GtkPrinterOptionWidgetPrivate));
-
signals[CHANGED] =
g_signal_new ("changed",
G_TYPE_FROM_CLASS (class),
static void
gtk_printer_option_widget_init (GtkPrinterOptionWidget *widget)
{
- widget->priv = GTK_PRINTER_OPTION_WIDGET_GET_PRIVATE (widget);
+ widget->priv = gtk_printer_option_widget_get_instance_private (widget);
gtk_box_set_spacing (GTK_BOX (widget), 12);
}
guint reverse : 1;
};
-#define GTK_PRINT_JOB_GET_PRIVATE(o) \
- (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_PRINT_JOB, GtkPrintJobPrivate))
-
static void gtk_print_job_finalize (GObject *object);
static void gtk_print_job_set_property (GObject *object,
guint prop_id,
static guint signals[LAST_SIGNAL] = { 0 };
-G_DEFINE_TYPE (GtkPrintJob, gtk_print_job, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkPrintJob, gtk_print_job, G_TYPE_OBJECT)
static void
gtk_print_job_class_init (GtkPrintJobClass *class)
object_class->set_property = gtk_print_job_set_property;
object_class->get_property = gtk_print_job_get_property;
- g_type_class_add_private (class, sizeof (GtkPrintJobPrivate));
-
g_object_class_install_property (object_class,
PROP_TITLE,
g_param_spec_string ("title",
{
GtkPrintJobPrivate *priv;
- priv = job->priv = GTK_PRINT_JOB_GET_PRIVATE (job);
+ priv = job->priv = gtk_print_job_get_instance_private (job);
priv->spool_io = NULL;
G_DEFINE_TYPE_WITH_CODE (GtkPrintOperation, gtk_print_operation, G_TYPE_OBJECT,
+ G_ADD_PRIVATE (GtkPrintOperation)
G_IMPLEMENT_INTERFACE (GTK_TYPE_PRINT_OPERATION_PREVIEW,
preview_iface_init))
GtkPrintOperationPrivate *priv;
const char *appname;
- priv = operation->priv = G_TYPE_INSTANCE_GET_PRIVATE (operation,
- GTK_TYPE_PRINT_OPERATION,
- GtkPrintOperationPrivate);
+ priv = operation->priv = gtk_print_operation_get_instance_private (operation);
priv->status = GTK_PRINT_STATUS_INITIAL;
priv->status_string = g_strdup ("");
class->preview = gtk_print_operation_preview_handler;
class->create_custom_widget = gtk_print_operation_create_custom_widget;
class->done = gtk_print_operation_done;
-
- g_type_class_add_private (gobject_class, sizeof (GtkPrintOperationPrivate));
/**
* GtkPrintOperation::done:
};
G_DEFINE_TYPE_WITH_CODE (GtkPrintUnixDialog, gtk_print_unix_dialog, GTK_TYPE_DIALOG,
+ G_ADD_PRIVATE (GtkPrintUnixDialog)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_print_unix_dialog_buildable_init))
gtk_widget_class_bind_callback (widget_class, update_number_up_layout);
gtk_widget_class_bind_callback (widget_class, redraw_page_layout_preview);
gtk_widget_class_bind_callback (widget_class, draw_page_cb);
-
- g_type_class_add_private (class, sizeof (GtkPrintUnixDialogPrivate));
}
/* Returns a toplevel GtkWindow, or NULL if none */
GtkPrintUnixDialogPrivate *priv;
GtkTreeSortable *sort;
- dialog->priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog,
- GTK_TYPE_PRINT_UNIX_DIALOG,
- GtkPrintUnixDialogPrivate);
+ dialog->priv = gtk_print_unix_dialog_get_instance_private (dialog);
priv = dialog->priv;
priv->print_backends = NULL;
GtkOrientation orientation);
G_DEFINE_TYPE_WITH_CODE (GtkProgressBar, gtk_progress_bar, GTK_TYPE_WIDGET,
+ G_ADD_PRIVATE (GtkProgressBar)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL))
static void
1, G_MAXINT, MIN_VERTICAL_BAR_HEIGHT,
G_PARAM_READWRITE));
- g_type_class_add_private (class, sizeof (GtkProgressBarPrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_PROGRESS_BAR_ACCESSIBLE);
}
{
GtkProgressBarPrivate *priv;
- pbar->priv = G_TYPE_INSTANCE_GET_PRIVATE (pbar,
- GTK_TYPE_PROGRESS_BAR,
- GtkProgressBarPrivate);
+ pbar->priv = gtk_progress_bar_get_instance_private (pbar);
priv = pbar->priv;
priv->orientation = GTK_ORIENTATION_HORIZONTAL;
GList *mime_types;
};
-G_DEFINE_TYPE (GtkQuery, _gtk_query, G_TYPE_OBJECT);
+G_DEFINE_TYPE_WITH_PRIVATE (GtkQuery, _gtk_query, G_TYPE_OBJECT)
static void
finalize (GObject *object)
gobject_class = G_OBJECT_CLASS (class);
gobject_class->finalize = finalize;
-
- g_type_class_add_private (gobject_class, sizeof (GtkQueryPrivate));
}
static void
_gtk_query_init (GtkQuery *query)
{
- query->priv = G_TYPE_INSTANCE_GET_PRIVATE (query, GTK_TYPE_QUERY, GtkQueryPrivate);
+ query->priv = _gtk_query_get_instance_private (query);
}
GtkQuery *
static GtkWidget *create_menu_item (GtkAction *action);
-G_DEFINE_TYPE (GtkRadioAction, gtk_radio_action, GTK_TYPE_TOGGLE_ACTION)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkRadioAction, gtk_radio_action, GTK_TYPE_TOGGLE_ACTION)
static guint radio_action_signals[LAST_SIGNAL] = { 0 };
G_STRUCT_OFFSET (GtkRadioActionClass, changed), NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1, GTK_TYPE_RADIO_ACTION);
-
- g_type_class_add_private (gobject_class, sizeof (GtkRadioActionPrivate));
}
static void
gtk_radio_action_init (GtkRadioAction *action)
{
- action->private_data = G_TYPE_INSTANCE_GET_PRIVATE (action,
- GTK_TYPE_RADIO_ACTION,
- GtkRadioActionPrivate);
-
+ action->private_data = gtk_radio_action_get_instance_private (action);
action->private_data->group = g_slist_prepend (NULL, action);
action->private_data->value = 0;
GValue *value,
GParamSpec *pspec);
-G_DEFINE_TYPE (GtkRadioButton, gtk_radio_button, GTK_TYPE_CHECK_BUTTON)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkRadioButton, gtk_radio_button, GTK_TYPE_CHECK_BUTTON)
static guint group_changed_signal = 0;
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
- g_type_class_add_private (class, sizeof (GtkRadioButtonPrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_RADIO_BUTTON_ACCESSIBLE);
}
{
GtkRadioButtonPrivate *priv;
- radio_button->priv = G_TYPE_INSTANCE_GET_PRIVATE (radio_button,
- GTK_TYPE_RADIO_BUTTON,
- GtkRadioButtonPrivate);
+ radio_button->priv = gtk_radio_button_get_instance_private (radio_button);
priv = radio_button->priv;
gtk_widget_set_receives_default (GTK_WIDGET (radio_button), FALSE);
static guint group_changed_signal = 0;
-G_DEFINE_TYPE (GtkRadioMenuItem, gtk_radio_menu_item, GTK_TYPE_CHECK_MENU_ITEM)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkRadioMenuItem, gtk_radio_menu_item, GTK_TYPE_CHECK_MENU_ITEM)
/**
* gtk_radio_menu_item_new:
NULL, NULL,
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
- g_type_class_add_private (klass, sizeof (GtkRadioMenuItemPrivate));
}
static void
{
GtkRadioMenuItemPrivate *priv;
- radio_menu_item->priv = G_TYPE_INSTANCE_GET_PRIVATE (radio_menu_item,
- GTK_TYPE_RADIO_MENU_ITEM,
- GtkRadioMenuItemPrivate);
+ radio_menu_item->priv = gtk_radio_menu_item_get_instance_private (radio_menu_item);
priv = radio_menu_item->priv;
priv->group = g_slist_prepend (NULL, radio_menu_item);
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GtkRange, gtk_range, GTK_TYPE_WIDGET,
+ G_ADD_PRIVATE (GtkRange)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE,
NULL))
0.0, 1.0, 0.5,
GTK_PARAM_READABLE));
- g_type_class_add_private (class, sizeof (GtkRangePrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_RANGE_ACCESSIBLE);
}
{
GtkRangePrivate *priv;
- range->priv = G_TYPE_INSTANCE_GET_PRIVATE (range,
- GTK_TYPE_RANGE,
- GtkRangePrivate);
+ range->priv = gtk_range_get_instance_private (range);
priv = range->priv;
gtk_widget_set_has_window (GTK_WIDGET (range), FALSE);
G_DEFINE_TYPE_WITH_CODE (GtkRecentAction,
gtk_recent_action,
GTK_TYPE_ACTION,
+ G_ADD_PRIVATE (GtkRecentAction)
G_IMPLEMENT_INTERFACE (GTK_TYPE_RECENT_CHOOSER,
gtk_recent_chooser_iface_init));
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GtkActionClass *action_class = GTK_ACTION_CLASS (klass);
- g_type_class_add_private (klass, sizeof (GtkRecentActionPrivate));
-
gobject_class->finalize = gtk_recent_action_finalize;
gobject_class->dispose = gtk_recent_action_dispose;
gobject_class->set_property = gtk_recent_action_set_property;
{
GtkRecentActionPrivate *priv;
- action->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (action,
- GTK_TYPE_RECENT_ACTION,
- GtkRecentActionPrivate);
+ action->priv = priv = gtk_recent_action_get_instance_private (action);
priv->show_numbers = FALSE;
priv->show_icons = TRUE;
G_DEFINE_TYPE_WITH_CODE (GtkRecentChooserDefault,
_gtk_recent_chooser_default,
GTK_TYPE_BOX,
+ G_ADD_PRIVATE (GtkRecentChooserDefault)
G_IMPLEMENT_INTERFACE (GTK_TYPE_RECENT_CHOOSER,
gtk_recent_chooser_iface_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,
gtk_widget_class_bind_callback (widget_class, recent_view_drag_begin_cb);
gtk_widget_class_bind_callback (widget_class, recent_view_drag_data_get_cb);
gtk_widget_class_bind_callback (widget_class, recent_view_query_tooltip_cb);
-
- g_type_class_add_private (gobject_class, sizeof (GtkRecentChooserDefaultPrivate));
}
static void
{
GtkRecentChooserDefaultPrivate *priv;
- impl->priv = priv =
- G_TYPE_INSTANCE_GET_PRIVATE (impl, GTK_TYPE_RECENT_CHOOSER_DEFAULT,
- GtkRecentChooserDefaultPrivate);
+ impl->priv = priv = _gtk_recent_chooser_default_get_instance_private (impl);
/* by default, we use the global manager */
priv->local_manager = FALSE;
G_DEFINE_TYPE_WITH_CODE (GtkRecentChooserDialog,
gtk_recent_chooser_dialog,
GTK_TYPE_DIALOG,
+ G_ADD_PRIVATE (GtkRecentChooserDialog)
G_IMPLEMENT_INTERFACE (GTK_TYPE_RECENT_CHOOSER,
_gtk_recent_chooser_delegate_iface_init))
gobject_class->finalize = gtk_recent_chooser_dialog_finalize;
_gtk_recent_chooser_install_properties (gobject_class);
-
- g_type_class_add_private (klass, sizeof (GtkRecentChooserDialogPrivate));
}
static void
gtk_recent_chooser_dialog_init (GtkRecentChooserDialog *dialog)
{
+ GtkRecentChooserDialogPrivate *priv;
GtkWidget *content_area, *action_area;
-
- GtkRecentChooserDialogPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog,
- GTK_TYPE_RECENT_CHOOSER_DIALOG,
- GtkRecentChooserDialogPrivate);
GtkDialog *rc_dialog = GTK_DIALOG (dialog);
-
+
+ priv = gtk_recent_chooser_dialog_get_instance_private (dialog);
dialog->priv = priv;
content_area = gtk_dialog_get_content_area (rc_dialog);
G_DEFINE_TYPE_WITH_CODE (GtkRecentChooserMenu,
gtk_recent_chooser_menu,
GTK_TYPE_MENU,
+ G_ADD_PRIVATE (GtkRecentChooserMenu)
G_IMPLEMENT_INTERFACE (GTK_TYPE_RECENT_CHOOSER,
gtk_recent_chooser_iface_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,
g_object_class_override_property (gobject_class, PROP_ACTIVATABLE_RELATED_ACTION, "related-action");
g_object_class_override_property (gobject_class, PROP_ACTIVATABLE_USE_ACTION_APPEARANCE, "use-action-appearance");
-
- g_type_class_add_private (klass, sizeof (GtkRecentChooserMenuPrivate));
}
static void
{
GtkRecentChooserMenuPrivate *priv;
- menu->priv = G_TYPE_INSTANCE_GET_PRIVATE (menu,
- GTK_TYPE_RECENT_CHOOSER_MENU,
- GtkRecentChooserMenuPrivate);
-
+ menu->priv = gtk_recent_chooser_menu_get_instance_private (menu);
priv = menu->priv;
priv->show_icons= TRUE;
GtkWidget *chooser;
};
-#define GTK_RECENT_CHOOSER_WIDGET_GET_PRIVATE(obj) (GTK_RECENT_CHOOSER_WIDGET (obj)->priv)
-
-static GObject *gtk_recent_chooser_widget_constructor (GType type,
- guint n_params,
- GObjectConstructParam *params);
static void gtk_recent_chooser_widget_set_property (GObject *object,
guint prop_id,
const GValue *value,
G_DEFINE_TYPE_WITH_CODE (GtkRecentChooserWidget,
gtk_recent_chooser_widget,
GTK_TYPE_BOX,
+ G_ADD_PRIVATE (GtkRecentChooserWidget)
G_IMPLEMENT_INTERFACE (GTK_TYPE_RECENT_CHOOSER,
_gtk_recent_chooser_delegate_iface_init))
static void
-gtk_recent_chooser_widget_class_init (GtkRecentChooserWidgetClass *klass)
+gtk_recent_chooser_widget_constructed (GObject *gobject)
{
- GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GtkRecentChooserWidget *self = GTK_RECENT_CHOOSER_WIDGET (gobject);
- gobject_class->constructor = gtk_recent_chooser_widget_constructor;
- gobject_class->set_property = gtk_recent_chooser_widget_set_property;
- gobject_class->get_property = gtk_recent_chooser_widget_get_property;
- gobject_class->finalize = gtk_recent_chooser_widget_finalize;
+ self->priv->chooser = _gtk_recent_chooser_default_new (self->priv->manager);
- _gtk_recent_chooser_install_properties (gobject_class);
-
- g_type_class_add_private (klass, sizeof (GtkRecentChooserWidgetPrivate));
-}
-
-
-static void
-gtk_recent_chooser_widget_init (GtkRecentChooserWidget *widget)
-{
- widget->priv = G_TYPE_INSTANCE_GET_PRIVATE (widget, GTK_TYPE_RECENT_CHOOSER_WIDGET,
- GtkRecentChooserWidgetPrivate);
-
- gtk_orientable_set_orientation (GTK_ORIENTABLE (widget),
- GTK_ORIENTATION_VERTICAL);
-}
-
-static GObject *
-gtk_recent_chooser_widget_constructor (GType type,
- guint n_params,
- GObjectConstructParam *params)
-{
- GObject *object;
- GtkRecentChooserWidgetPrivate *priv;
-
- object = G_OBJECT_CLASS (gtk_recent_chooser_widget_parent_class)->constructor (type,
- n_params,
- params);
-
- priv = GTK_RECENT_CHOOSER_WIDGET_GET_PRIVATE (object);
- priv->chooser = _gtk_recent_chooser_default_new (priv->manager);
-
-
- gtk_container_add (GTK_CONTAINER (object), priv->chooser);
- gtk_widget_show (priv->chooser);
- _gtk_recent_chooser_set_delegate (GTK_RECENT_CHOOSER (object),
- GTK_RECENT_CHOOSER (priv->chooser));
-
- return object;
+ gtk_container_add (GTK_CONTAINER (self), self->priv->chooser);
+ gtk_widget_show (self->priv->chooser);
+ _gtk_recent_chooser_set_delegate (GTK_RECENT_CHOOSER (self),
+ GTK_RECENT_CHOOSER (self->priv->chooser));
}
static void
{
GtkRecentChooserWidgetPrivate *priv;
- priv = GTK_RECENT_CHOOSER_WIDGET_GET_PRIVATE (object);
+ priv = gtk_recent_chooser_widget_get_instance_private (GTK_RECENT_CHOOSER_WIDGET (object));
switch (prop_id)
{
{
GtkRecentChooserWidgetPrivate *priv;
- priv = GTK_RECENT_CHOOSER_WIDGET_GET_PRIVATE (object);
+ priv = gtk_recent_chooser_widget_get_instance_private (GTK_RECENT_CHOOSER_WIDGET (object));
g_object_get_property (G_OBJECT (priv->chooser), pspec->name, value);
}
static void
gtk_recent_chooser_widget_finalize (GObject *object)
{
- GtkRecentChooserWidgetPrivate *priv;
-
- priv = GTK_RECENT_CHOOSER_WIDGET_GET_PRIVATE (object);
- priv->manager = NULL;
+ GtkRecentChooserWidget *self = GTK_RECENT_CHOOSER_WIDGET (object);
+
+ self->priv->manager = NULL;
G_OBJECT_CLASS (gtk_recent_chooser_widget_parent_class)->finalize (object);
}
+static void
+gtk_recent_chooser_widget_class_init (GtkRecentChooserWidgetClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+ gobject_class->constructed = gtk_recent_chooser_widget_constructed;
+ gobject_class->set_property = gtk_recent_chooser_widget_set_property;
+ gobject_class->get_property = gtk_recent_chooser_widget_get_property;
+ gobject_class->finalize = gtk_recent_chooser_widget_finalize;
+
+ _gtk_recent_chooser_install_properties (gobject_class);
+}
+
+static void
+gtk_recent_chooser_widget_init (GtkRecentChooserWidget *widget)
+{
+ widget->priv = gtk_recent_chooser_widget_get_instance_private (widget);
+
+ gtk_orientable_set_orientation (GTK_ORIENTABLE (widget),
+ GTK_ORIENTATION_VERTICAL);
+}
+
/*
* Public API
*/
static GtkRecentManager *recent_manager_singleton = NULL;
-G_DEFINE_TYPE (GtkRecentManager, gtk_recent_manager, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkRecentManager, gtk_recent_manager, G_TYPE_OBJECT)
static void
filename_warning (const gchar *format,
G_TYPE_NONE, 0);
klass->changed = gtk_recent_manager_real_changed;
-
- g_type_class_add_private (klass, sizeof (GtkRecentManagerPrivate));
}
static void
GtkRecentManagerPrivate *priv;
GtkSettings *settings;
- manager->priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
- GTK_TYPE_RECENT_MANAGER,
- GtkRecentManagerPrivate);
+ manager->priv = gtk_recent_manager_get_instance_private (manager);
priv = manager->priv;
priv->size = 0;
gint *minimum_width,
gint *natural_width);
-G_DEFINE_TYPE_WITH_PRIVATE (GtkRevealer, gtk_revealer, GTK_TYPE_BIN);
-
+G_DEFINE_TYPE_WITH_PRIVATE (GtkRevealer, gtk_revealer, GTK_TYPE_BIN)
static void
gtk_revealer_init (GtkRevealer *revealer)
G_DEFINE_TYPE_WITH_CODE (GtkScale, gtk_scale, GTK_TYPE_RANGE,
+ G_ADD_PRIVATE (GtkScale)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_scale_buildable_interface_init))
add_slider_binding (binding_set, GDK_KEY_KP_End, 0,
GTK_SCROLL_END);
- g_type_class_add_private (gobject_class, sizeof (GtkScalePrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_SCALE_ACCESSIBLE);
}
GtkRange *range = GTK_RANGE (scale);
GtkStyleContext *context;
- scale->priv = G_TYPE_INSTANCE_GET_PRIVATE (scale,
- GTK_TYPE_SCALE,
- GtkScalePrivate);
+ scale->priv = gtk_scale_get_instance_private (scale);
priv = scale->priv;
gtk_widget_set_can_focus (GTK_WIDGET (scale), TRUE);
gtk_range_set_round_digits (range, priv->digits);
gtk_range_set_flippable (range,
- gtk_orientable_get_orientation (GTK_ORIENTABLE (range))== GTK_ORIENTATION_HORIZONTAL);
+ gtk_orientable_get_orientation (GTK_ORIENTABLE (range)) == GTK_ORIENTATION_HORIZONTAL);
context = gtk_widget_get_style_context (GTK_WIDGET (scale));
gtk_style_context_add_class (context, GTK_STYLE_CLASS_SCALE);
static void gtk_scale_button_scale_value_changed(GtkRange *range);
G_DEFINE_TYPE_WITH_CODE (GtkScaleButton, gtk_scale_button, GTK_TYPE_BUTTON,
+ G_ADD_PRIVATE (GtkScaleButton)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE,
NULL))
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GtkBindingSet *binding_set;
- g_type_class_add_private (klass, sizeof (GtkScaleButtonPrivate));
-
gobject_class->constructor = gtk_scale_button_constructor;
gobject_class->finalize = gtk_scale_button_finalize;
gobject_class->dispose = gtk_scale_button_dispose;
{
GtkScaleButtonPrivate *priv;
- button->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (button,
- GTK_TYPE_SCALE_BUTTON,
- GtkScaleButtonPrivate);
+ button->priv = priv = gtk_scale_button_get_instance_private (button);
priv->timeout = FALSE;
priv->click_id = 0;
static guint signals[LAST_SIGNAL] = {0};
-G_DEFINE_TYPE (GtkScrolledWindow, gtk_scrolled_window, GTK_TYPE_BIN)
-
+G_DEFINE_TYPE_WITH_PRIVATE (GtkScrolledWindow, gtk_scrolled_window, GTK_TYPE_BIN)
static void
add_scroll_binding (GtkBindingSet *binding_set,
add_tab_bindings (binding_set, GDK_CONTROL_MASK, GTK_DIR_TAB_FORWARD);
add_tab_bindings (binding_set, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
- g_type_class_add_private (class, sizeof (GtkScrolledWindowPrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE);
}
{
GtkScrolledWindowPrivate *priv;
- scrolled_window->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (scrolled_window,
- GTK_TYPE_SCROLLED_WINDOW,
- GtkScrolledWindowPrivate);
+ scrolled_window->priv = priv =
+ gtk_scrolled_window_get_instance_private (scrolled_window);
gtk_widget_set_has_window (GTK_WIDGET (scrolled_window), FALSE);
gtk_widget_set_can_focus (GTK_WIDGET (scrolled_window), TRUE);
* Since: 3.10
*/
-G_DEFINE_TYPE (GtkSearchBar, gtk_search_bar, GTK_TYPE_BIN)
-
-struct _GtkSearchBarPrivate {
+typedef struct {
/* Template widgets */
GtkWidget *revealer;
GtkWidget *toolbar;
GtkWidget *entry;
gboolean reveal_child;
-};
+} GtkSearchBarPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE (GtkSearchBar, gtk_search_bar, GTK_TYPE_BIN)
enum {
PROP_0,
GdkEvent *event,
GtkSearchBar *bar)
{
+ GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);
guint keyval;
if (!gdk_event_get_keyval (event, &keyval) ||
keyval != GDK_KEY_Escape)
return GDK_EVENT_PROPAGATE;
- gtk_revealer_set_reveal_child (GTK_REVEALER (bar->priv->revealer), FALSE);
+ gtk_revealer_set_reveal_child (GTK_REVEALER (priv->revealer), FALSE);
+
return GDK_EVENT_STOP;
}
gtk_search_bar_handle_event (GtkSearchBar *bar,
GdkEvent *event)
{
+ GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);
guint keyval;
gboolean handled;
gboolean preedit_changed;
gboolean res;
char *old_text, *new_text;
- if (!bar->priv->entry)
+ if (priv->entry == NULL)
{
g_warning ("The search bar does not have an entry connected to it. Call gtk_search_bar_connect_entry() to connect one.");
return GDK_EVENT_PROPAGATE;
* the event doesn't contain a key press,
* or the event is a navigation or space bar key press
*/
- if (bar->priv->reveal_child ||
+ if (priv->reveal_child ||
!gdk_event_get_keyval (event, &keyval) ||
is_keynav_event (event, keyval) ||
keyval == GDK_KEY_space)
return GDK_EVENT_PROPAGATE;
- if (!gtk_widget_get_realized (bar->priv->entry))
- gtk_widget_realize (bar->priv->entry);
+ if (!gtk_widget_get_realized (priv->entry))
+ gtk_widget_realize (priv->entry);
handled = GDK_EVENT_PROPAGATE;
preedit_changed = FALSE;
- preedit_change_id = g_signal_connect (bar->priv->entry, "preedit-changed",
+ preedit_change_id = g_signal_connect (priv->entry, "preedit-changed",
G_CALLBACK (preedit_changed_cb), &preedit_changed);
- old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (bar->priv->entry)));
- res = gtk_widget_event (bar->priv->entry, event);
- new_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (bar->priv->entry)));
+ old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (priv->entry)));
+ res = gtk_widget_event (priv->entry, event);
+ new_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (priv->entry)));
- g_signal_handler_disconnect (bar->priv->entry, preedit_change_id);
+ g_signal_handler_disconnect (priv->entry, preedit_change_id);
if ((res && g_strcmp0 (new_text, old_text) != 0) || preedit_changed)
{
handled = GDK_EVENT_STOP;
- gtk_revealer_set_reveal_child (GTK_REVEALER (bar->priv->revealer), TRUE);
+ gtk_revealer_set_reveal_child (GTK_REVEALER (priv->revealer), TRUE);
}
g_free (old_text);
GParamSpec *pspec,
GtkSearchBar *bar)
{
+ GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);
gboolean reveal_child;
g_object_get (object, "reveal-child", &reveal_child, NULL);
- if (reveal_child == bar->priv->reveal_child)
+ if (reveal_child == priv->reveal_child)
return;
- bar->priv->reveal_child = reveal_child;
+ priv->reveal_child = reveal_child;
if (reveal_child)
- _gtk_entry_grab_focus (GTK_ENTRY (bar->priv->entry), FALSE);
+ _gtk_entry_grab_focus (GTK_ENTRY (priv->entry), FALSE);
else
- gtk_entry_set_text (GTK_ENTRY (bar->priv->entry), "");
+ gtk_entry_set_text (GTK_ENTRY (priv->entry), "");
g_object_notify (G_OBJECT (bar), "search-mode-enabled");
}
close_button_clicked_cb (GtkWidget *button,
GtkSearchBar *bar)
{
- gtk_revealer_set_reveal_child (GTK_REVEALER (bar->priv->revealer), FALSE);
+ GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);
+
+ gtk_revealer_set_reveal_child (GTK_REVEALER (priv->revealer), FALSE);
}
static void
GtkWidget *child)
{
GtkSearchBar *bar = GTK_SEARCH_BAR (container);
+ GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);
/* When constructing the widget, we want the revealer to be added
* as the first child of the search bar, as an implementation detail.
* After that, the child added by the application should be added
* to the toolbar's box_center.
*/
- if (bar->priv->box_center == NULL)
+ if (priv->box_center == NULL)
{
GTK_CONTAINER_CLASS (gtk_search_bar_parent_class)->add (container, child);
}
else
{
- gtk_container_add (GTK_CONTAINER (bar->priv->box_center), child);
+ gtk_container_add (GTK_CONTAINER (priv->box_center), child);
/* If an entry is the only child, save the developer a couple of
* lines of code
*/
GParamSpec *pspec)
{
GtkSearchBar *bar = GTK_SEARCH_BAR (object);
+ GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);
switch (prop_id)
{
case PROP_SEARCH_MODE_ENABLED:
- g_value_set_boolean (value, bar->priv->reveal_child);
+ g_value_set_boolean (value, priv->reveal_child);
break;
case PROP_SHOW_CLOSE_BUTTON:
g_value_set_boolean (value, gtk_search_bar_get_show_close_button (bar));
gtk_search_bar_dispose (GObject *object)
{
GtkSearchBar *bar = GTK_SEARCH_BAR (object);
+ GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);
- if (bar->priv->entry)
+ if (priv->entry)
{
- g_signal_handlers_disconnect_by_func (bar->priv->entry, entry_key_pressed_event_cb, bar);
- g_object_remove_weak_pointer (G_OBJECT (bar->priv->entry), (gpointer *) &bar->priv->entry);
- bar->priv->entry = NULL;
+ g_signal_handlers_disconnect_by_func (priv->entry, entry_key_pressed_event_cb, bar);
+ g_object_remove_weak_pointer (G_OBJECT (priv->entry), (gpointer *) &priv->entry);
+ priv->entry = NULL;
}
G_OBJECT_CLASS (gtk_search_bar_parent_class)->dispose (object);
gtk_widget_class_bind_child_internal (widget_class, GtkSearchBarPrivate, revealer);
gtk_widget_class_bind_child_internal (widget_class, GtkSearchBarPrivate, box_center);
gtk_widget_class_bind_child_internal (widget_class, GtkSearchBarPrivate, close_button);
-
- g_type_class_add_private (klass, sizeof (GtkSearchBarPrivate));
}
static void
gtk_search_bar_init (GtkSearchBar *bar)
{
- bar->priv = G_TYPE_INSTANCE_GET_PRIVATE (bar, GTK_TYPE_SEARCH_BAR, GtkSearchBarPrivate);
+ GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);
gtk_widget_init_template (GTK_WIDGET (bar));
- gtk_widget_show_all (bar->priv->toolbar);
+ gtk_widget_show_all (priv->toolbar);
- g_signal_connect (bar->priv->revealer, "notify::reveal-child",
+ g_signal_connect (priv->revealer, "notify::reveal-child",
G_CALLBACK (reveal_child_changed_cb), bar);
- gtk_widget_set_no_show_all (bar->priv->close_button, TRUE);
- g_signal_connect (bar->priv->close_button, "clicked",
+ gtk_widget_set_no_show_all (priv->close_button, TRUE);
+ g_signal_connect (priv->close_button, "clicked",
G_CALLBACK (close_button_clicked_cb), bar);
};
gtk_search_bar_connect_entry (GtkSearchBar *bar,
GtkEntry *entry)
{
+ GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);
+
g_return_if_fail (GTK_IS_SEARCH_BAR (bar));
g_return_if_fail (entry == NULL || GTK_IS_ENTRY (entry));
- if (bar->priv->entry != NULL)
+ if (priv->entry != NULL)
{
- g_signal_handlers_disconnect_by_func (bar->priv->entry, entry_key_pressed_event_cb, bar);
- g_object_remove_weak_pointer (G_OBJECT (bar->priv->entry), (gpointer *) &bar->priv->entry);
- bar->priv->entry = NULL;
+ g_signal_handlers_disconnect_by_func (priv->entry, entry_key_pressed_event_cb, bar);
+ g_object_remove_weak_pointer (G_OBJECT (priv->entry), (gpointer *) &priv->entry);
+ priv->entry = NULL;
}
if (entry != NULL)
{
- bar->priv->entry = GTK_WIDGET (entry);
- g_object_add_weak_pointer (G_OBJECT (bar->priv->entry), (gpointer *) &bar->priv->entry);
- g_signal_connect (bar->priv->entry, "key-press-event",
+ priv->entry = GTK_WIDGET (entry);
+ g_object_add_weak_pointer (G_OBJECT (priv->entry), (gpointer *) &priv->entry);
+ g_signal_connect (priv->entry, "key-press-event",
G_CALLBACK (entry_key_pressed_event_cb), bar);
}
}
gboolean
gtk_search_bar_get_search_mode (GtkSearchBar *bar)
{
+ GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);
+
g_return_val_if_fail (GTK_IS_SEARCH_BAR (bar), FALSE);
- return bar->priv->reveal_child;
+ return priv->reveal_child;
}
/**
gtk_search_bar_set_search_mode (GtkSearchBar *bar,
gboolean search_mode)
{
+ GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);
+
g_return_if_fail (GTK_IS_SEARCH_BAR (bar));
- gtk_revealer_set_reveal_child (GTK_REVEALER (bar->priv->revealer), search_mode);
+ gtk_revealer_set_reveal_child (GTK_REVEALER (priv->revealer), search_mode);
}
/**
gboolean
gtk_search_bar_get_show_close_button (GtkSearchBar *bar)
{
+ GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);
+
g_return_val_if_fail (GTK_IS_SEARCH_BAR (bar), FALSE);
- return gtk_widget_get_visible (bar->priv->close_button);
+ return gtk_widget_get_visible (priv->close_button);
}
/**
gtk_search_bar_set_show_close_button (GtkSearchBar *bar,
gboolean visible)
{
+ GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);
+
g_return_if_fail (GTK_IS_SEARCH_BAR (bar));
- gtk_widget_set_visible (bar->priv->close_button, visible);
+ gtk_widget_set_visible (priv->close_button, visible);
}
#define GTK_SEARCH_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SEARCH_BAR, GtkSearchBarClass))
typedef struct _GtkSearchBar GtkSearchBar;
-typedef struct _GtkSearchBarPrivate GtkSearchBarPrivate;
typedef struct _GtkSearchBarClass GtkSearchBarClass;
struct _GtkSearchBar
{
/*< private >*/
GtkBin parent;
-
- GtkSearchBarPrivate *priv;
};
struct _GtkSearchBarClass
gboolean query_finished;
};
-G_DEFINE_TYPE (GtkSearchEngineQuartz, _gtk_search_engine_quartz, GTK_TYPE_SEARCH_ENGINE);
+G_DEFINE_TYPE_WITH_PRIVATE (GtkSearchEngineQuartz, _gtk_search_engine_quartz, GTK_TYPE_SEARCH_ENGINE)
/* Implementation of the objective-C object */
engine_class->start = gtk_search_engine_quartz_start;
engine_class->stop = gtk_search_engine_quartz_stop;
engine_class->is_indexed = gtk_search_engine_quartz_is_indexed;
-
- g_type_class_add_private (gobject_class, sizeof (GtkSearchEngineQuartzPrivate));
}
static void
{
QUARTZ_POOL_ALLOC;
- engine->priv = G_TYPE_INSTANCE_GET_PRIVATE (engine, GTK_TYPE_SEARCH_ENGINE_QUARTZ, GtkSearchEngineQuartzPrivate);
+ engine->priv = _gtk_search_engine_quartz_get_instance_private (engine);
engine->priv->ns_query = [[NSMetadataQuery alloc] init];
engine->priv->receiver = [[ResultReceiver alloc] init];
};
-G_DEFINE_TYPE (GtkSearchEngineSimple, _gtk_search_engine_simple, GTK_TYPE_SEARCH_ENGINE);
+G_DEFINE_TYPE_WITH_PRIVATE (GtkSearchEngineSimple, _gtk_search_engine_simple, GTK_TYPE_SEARCH_ENGINE)
static void
gtk_search_engine_simple_dispose (GObject *object)
engine_class->start = gtk_search_engine_simple_start;
engine_class->stop = gtk_search_engine_simple_stop;
engine_class->is_indexed = gtk_search_engine_simple_is_indexed;
-
- g_type_class_add_private (gobject_class, sizeof (GtkSearchEngineSimplePrivate));
}
static void
_gtk_search_engine_simple_init (GtkSearchEngineSimple *engine)
{
- engine->priv = G_TYPE_INSTANCE_GET_PRIVATE (engine, GTK_TYPE_SEARCH_ENGINE_SIMPLE, GtkSearchEngineSimplePrivate);
+ engine->priv = _gtk_search_engine_simple_get_instance_private (engine);
}
GtkSearchEngine *
gboolean query_pending;
};
-G_DEFINE_TYPE (GtkSearchEngineTracker, _gtk_search_engine_tracker, GTK_TYPE_SEARCH_ENGINE);
+G_DEFINE_TYPE_WITH_PRIVATE (GtkSearchEngineTracker, _gtk_search_engine_tracker, GTK_TYPE_SEARCH_ENGINE)
static void
finalize (GObject *object)
engine_class->start = gtk_search_engine_tracker_start;
engine_class->stop = gtk_search_engine_tracker_stop;
engine_class->is_indexed = gtk_search_engine_tracker_is_indexed;
-
- g_type_class_add_private (gobject_class,
- sizeof (GtkSearchEngineTrackerPrivate));
}
static void
_gtk_search_engine_tracker_init (GtkSearchEngineTracker *engine)
{
- engine->priv = G_TYPE_INSTANCE_GET_PRIVATE (engine,
- GTK_TYPE_SEARCH_ENGINE_TRACKER,
- GtkSearchEngineTrackerPrivate);
+ engine->priv = _gtk_search_engine_tracker_get_instance_private (engine);
}
* Since: 3.6
*/
-G_DEFINE_TYPE (GtkSearchEntry, gtk_search_entry, GTK_TYPE_ENTRY)
-
typedef struct {
guint delayed_changed_id;
gboolean in_timeout;
} GtkSearchEntryPrivate;
+G_DEFINE_TYPE_WITH_PRIVATE (GtkSearchEntry, gtk_search_entry, GTK_TYPE_ENTRY)
+
/* 150 mseconds of delay */
#define DELAYED_TIMEOUT_ID 150
/* This widget got created without a private structure, meaning
* that we cannot now have one without breaking ABI */
-#define GET_PRIV(e) G_TYPE_INSTANCE_GET_PRIVATE (e, GTK_TYPE_SEARCH_ENTRY, GtkSearchEntryPrivate)
+#define GET_PRIV(e) ((GtkSearchEntryPrivate *) gtk_search_entry_get_instance_private ((GtkSearchEntry *) (e)))
static void
gtk_search_entry_finalize (GObject *object)
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gtk_search_entry_finalize;
-
- g_type_class_add_private (klass, sizeof (GtkSearchEntryPrivate));
}
static void
G_DEFINE_TYPE_WITH_CODE (GtkSeparator, gtk_separator, GTK_TYPE_WIDGET,
- G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE,
- NULL))
+ G_ADD_PRIVATE (GtkSeparator)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL))
static void
gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_SEPARATOR);
g_object_class_override_property (object_class, PROP_ORIENTATION, "orientation");
-
- g_type_class_add_private (object_class, sizeof (GtkSeparatorPrivate));
}
static void
gtk_separator_init (GtkSeparator *separator)
{
- GtkSeparatorPrivate *private;
GtkStyleContext *context;
- separator->priv = G_TYPE_INSTANCE_GET_PRIVATE (separator,
- GTK_TYPE_SEPARATOR,
- GtkSeparatorPrivate);
- private = separator->priv;
+ separator->priv = gtk_separator_get_instance_private (separator);
+ separator->priv->orientation = GTK_ORIENTATION_HORIZONTAL;
gtk_widget_set_has_window (GTK_WIDGET (separator), FALSE);
- private->orientation = GTK_ORIENTATION_HORIZONTAL;
-
context = gtk_widget_get_style_context (GTK_WIDGET (separator));
gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
}
GdkEventButton *event);
-G_DEFINE_TYPE (GtkSeparatorToolItem, gtk_separator_tool_item, GTK_TYPE_TOOL_ITEM)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkSeparatorToolItem, gtk_separator_tool_item, GTK_TYPE_TOOL_ITEM)
static gint
get_space_size (GtkToolItem *tool_item)
P_("Whether the separator is drawn, or just blank"),
TRUE,
GTK_PARAM_READWRITE));
-
-
- g_type_class_add_private (object_class, sizeof (GtkSeparatorToolItemPrivate));
}
static void
{
GtkStyleContext *context;
- separator_item->priv = G_TYPE_INSTANCE_GET_PRIVATE (separator_item,
- GTK_TYPE_SEPARATOR_TOOL_ITEM,
- GtkSeparatorToolItemPrivate);
+ separator_item->priv = gtk_separator_tool_item_get_instance_private (separator_item);
separator_item->priv->draw = TRUE;
gtk_widget_set_has_window (GTK_WIDGET (separator_item), FALSE);
G_DEFINE_TYPE_EXTENDED (GtkSettings, gtk_settings, G_TYPE_OBJECT, 0,
+ G_ADD_PRIVATE (GtkSettings)
G_IMPLEMENT_INTERFACE (GTK_TYPE_STYLE_PROVIDER,
gtk_settings_provider_iface_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_STYLE_PROVIDER_PRIVATE,
const gchar * const *config_dirs;
const gchar *config_dir;
- priv = G_TYPE_INSTANCE_GET_PRIVATE (settings,
- GTK_TYPE_SETTINGS,
- GtkSettingsPrivate);
-
+ priv = gtk_settings_get_instance_private (settings);
settings->priv = priv;
+
g_datalist_init (&priv->queued_settings);
object_list = g_slist_prepend (object_list, settings);
GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_RECENT_FILES_ENABLED);
-
- g_type_class_add_private (class, sizeof (GtkSettingsPrivate));
}
static void
G_STATIC_ASSERT (GTK_SIZE_GROUP_VERTICAL == (1 << GTK_ORIENTATION_VERTICAL));
G_STATIC_ASSERT (GTK_SIZE_GROUP_BOTH == (GTK_SIZE_GROUP_HORIZONTAL | GTK_SIZE_GROUP_VERTICAL));
+G_DEFINE_TYPE_WITH_CODE (GtkSizeGroup, gtk_size_group, G_TYPE_OBJECT,
+ G_ADD_PRIVATE (GtkSizeGroup)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
+ gtk_size_group_buildable_init))
+
static void
add_widget_to_closure (GHashTable *widgets,
GHashTable *groups,
"when determining the size of the group"),
FALSE,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (klass, sizeof (GtkSizeGroupPrivate));
}
static void
{
GtkSizeGroupPrivate *priv;
- size_group->priv = G_TYPE_INSTANCE_GET_PRIVATE (size_group,
- GTK_TYPE_SIZE_GROUP,
- GtkSizeGroupPrivate);
+ size_group->priv = gtk_size_group_get_instance_private (size_group);
priv = size_group->priv;
priv->widgets = NULL;
iface->custom_finished = gtk_size_group_buildable_custom_finished;
}
-G_DEFINE_TYPE_WITH_CODE (GtkSizeGroup, gtk_size_group, G_TYPE_OBJECT,
- G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
- gtk_size_group_buildable_init))
-
static void
gtk_size_group_set_property (GObject *object,
guint prop_id,
static guint socket_signals[LAST_SIGNAL] = { 0 };
-G_DEFINE_TYPE (GtkSocket, gtk_socket, GTK_TYPE_CONTAINER)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkSocket, gtk_socket, GTK_TYPE_CONTAINER)
static void
gtk_socket_finalize (GObject *object)
_gtk_boolean_handled_accumulator, NULL,
_gtk_marshal_BOOLEAN__VOID,
G_TYPE_BOOLEAN, 0);
-
- g_type_class_add_private (gobject_class, sizeof (GtkSocketPrivate));
}
static void
{
GtkSocketPrivate *priv;
- priv = G_TYPE_INSTANCE_GET_PRIVATE (socket,
- GTK_TYPE_SOCKET,
- GtkSocketPrivate);
+ priv = gtk_socket_get_instance_private (socket);
socket->priv = priv;
+
priv->request_width = 0;
priv->request_height = 0;
priv->current_width = 0;
static guint spinbutton_signals[LAST_SIGNAL] = {0};
G_DEFINE_TYPE_WITH_CODE (GtkSpinButton, gtk_spin_button, GTK_TYPE_ENTRY,
+ G_ADD_PRIVATE (GtkSpinButton)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL)
G_IMPLEMENT_INTERFACE (GTK_TYPE_EDITABLE,
gtk_spin_button_editable_init))
add_spin_binding (binding_set, GDK_KEY_Page_Up, GDK_CONTROL_MASK, GTK_SCROLL_END);
add_spin_binding (binding_set, GDK_KEY_Page_Down, GDK_CONTROL_MASK, GTK_SCROLL_START);
- g_type_class_add_private (class, sizeof (GtkSpinButtonPrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_SPIN_BUTTON_ACCESSIBLE);
}
GtkSpinButtonPrivate *priv;
GtkStyleContext *context;
- spin_button->priv = G_TYPE_INSTANCE_GET_PRIVATE (spin_button,
- GTK_TYPE_SPIN_BUTTON,
- GtkSpinButtonPrivate);
+ spin_button->priv = gtk_spin_button_get_instance_private (spin_button);
priv = spin_button->priv;
priv->adjustment = NULL;
gint *natural_size);
-G_DEFINE_TYPE (GtkSpinner, gtk_spinner, GTK_TYPE_WIDGET)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkSpinner, gtk_spinner, GTK_TYPE_WIDGET)
static void
gtk_spinner_class_init (GtkSpinnerClass *klass)
GtkWidgetClass *widget_class;
gobject_class = G_OBJECT_CLASS(klass);
- g_type_class_add_private (gobject_class, sizeof (GtkSpinnerPrivate));
gobject_class->get_property = gtk_spinner_get_property;
gobject_class->set_property = gtk_spinner_set_property;
static void
gtk_spinner_init (GtkSpinner *spinner)
{
- GtkSpinnerPrivate *priv;
GtkStyleContext *context;
- priv = G_TYPE_INSTANCE_GET_PRIVATE (spinner,
- GTK_TYPE_SPINNER,
- GtkSpinnerPrivate);
- spinner->priv = priv;
+ spinner->priv = gtk_spinner_get_instance_private (spinner);
gtk_widget_set_has_window (GTK_WIDGET (spinner), FALSE);
static gint get_bin_window_y (GtkStack *stack,
GtkAllocation *allocation);
-G_DEFINE_TYPE_WITH_PRIVATE(GtkStack, gtk_stack, GTK_TYPE_CONTAINER);
+G_DEFINE_TYPE_WITH_PRIVATE (GtkStack, gtk_stack, GTK_TYPE_CONTAINER)
static void
gtk_stack_init (GtkStack *stack)
PROP_STACK
};
-G_DEFINE_TYPE (GtkStackSwitcher, gtk_stack_switcher, GTK_TYPE_BOX);
+G_DEFINE_TYPE_WITH_PRIVATE (GtkStackSwitcher, gtk_stack_switcher, GTK_TYPE_BOX)
static void
gtk_stack_switcher_init (GtkStackSwitcher *switcher)
GtkStyleContext *context;
GtkStackSwitcherPrivate *priv;
- priv = G_TYPE_INSTANCE_GET_PRIVATE (switcher, GTK_TYPE_STACK_SWITCHER, GtkStackSwitcherPrivate);
+ priv = gtk_stack_switcher_get_instance_private (switcher);
switcher->priv = priv;
priv->stack = NULL;
GTK_TYPE_STACK,
GTK_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
-
- g_type_class_add_private (object_class, sizeof (GtkStackSwitcherPrivate));
}
/**
GtkWidget *
gtk_stack_switcher_new (void)
{
- return GTK_WIDGET (g_object_new (GTK_TYPE_STACK_SWITCHER, NULL));
+ return g_object_new (GTK_TYPE_STACK_SWITCHER, NULL);
}
static guint statusbar_signals[SIGNAL_LAST] = { 0 };
-G_DEFINE_TYPE (GtkStatusbar, gtk_statusbar, GTK_TYPE_BOX);
+G_DEFINE_TYPE_WITH_PRIVATE (GtkStatusbar, gtk_statusbar, GTK_TYPE_BOX)
static void
gtk_statusbar_class_init (GtkStatusbarClass *class)
gtk_widget_class_bind_child (widget_class, GtkStatusbarPrivate, frame);
gtk_widget_class_bind_child (widget_class, GtkStatusbarPrivate, label);
- g_type_class_add_private (class, sizeof (GtkStatusbarPrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_STATUSBAR_ACCESSIBLE);
}
GtkStatusbarPrivate *priv;
GtkShadowType shadow_type;
- statusbar->priv = G_TYPE_INSTANCE_GET_PRIVATE (statusbar,
- GTK_TYPE_STATUSBAR,
- GtkStatusbarPrivate);
+ statusbar->priv = gtk_statusbar_get_instance_private (statusbar);
priv = statusbar->priv;
priv->seq_context_id = 1;
static void gtk_status_icon_reset_image_data (GtkStatusIcon *status_icon);
static void gtk_status_icon_update_image (GtkStatusIcon *status_icon);
-G_DEFINE_TYPE (GtkStatusIcon, gtk_status_icon, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkStatusIcon, gtk_status_icon, G_TYPE_OBJECT)
static void
gtk_status_icon_class_init (GtkStatusIconClass *class)
G_TYPE_INT,
G_TYPE_BOOLEAN,
GTK_TYPE_TOOLTIP);
-
- g_type_class_add_private (class, sizeof (GtkStatusIconPrivate));
}
#ifdef GDK_WINDOWING_WIN32
{
GtkStatusIconPrivate *priv;
- priv = G_TYPE_INSTANCE_GET_PRIVATE (status_icon, GTK_TYPE_STATUS_ICON,
- GtkStatusIconPrivate);
+ priv = gtk_status_icon_get_instance_private (status_icon);
status_icon->priv = priv;
priv->icon_helper = _gtk_icon_helper_new ();
static void gtk_style_context_disconnect_update (GtkStyleContext *context);
static void gtk_style_context_connect_update (GtkStyleContext *context);
-G_DEFINE_TYPE (GtkStyleContext, gtk_style_context, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkStyleContext, gtk_style_context, G_TYPE_OBJECT)
static void
gtk_style_context_real_changed (GtkStyleContext *context)
P_("The parent style context"),
GTK_TYPE_STYLE_CONTEXT,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (object_class, sizeof (GtkStyleContextPrivate));
}
static StyleData *
{
GtkStyleContextPrivate *priv;
- priv = style_context->priv = G_TYPE_INSTANCE_GET_PRIVATE (style_context,
- GTK_TYPE_STYLE_CONTEXT,
- GtkStyleContextPrivate);
+ priv = style_context->priv =
+ gtk_style_context_get_instance_private (style_context);
priv->style_data = g_hash_table_new_full (style_info_hash,
style_info_equal,
static void gtk_style_properties_finalize (GObject *object);
-G_DEFINE_TYPE_EXTENDED (GtkStyleProperties, gtk_style_properties, G_TYPE_OBJECT, 0,
- G_IMPLEMENT_INTERFACE (GTK_TYPE_STYLE_PROVIDER,
- gtk_style_properties_provider_init)
- G_IMPLEMENT_INTERFACE (GTK_TYPE_STYLE_PROVIDER_PRIVATE,
- gtk_style_properties_provider_private_init));
+G_DEFINE_TYPE_WITH_CODE (GtkStyleProperties, gtk_style_properties, G_TYPE_OBJECT,
+ G_ADD_PRIVATE (GtkStyleProperties)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_STYLE_PROVIDER,
+ gtk_style_properties_provider_init)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_STYLE_PROVIDER_PRIVATE,
+ gtk_style_properties_provider_private_init));
static void
gtk_style_properties_class_init (GtkStylePropertiesClass *klass)
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gtk_style_properties_finalize;
-
- g_type_class_add_private (object_class, sizeof (GtkStylePropertiesPrivate));
}
static PropertyData *
static void
gtk_style_properties_init (GtkStyleProperties *props)
{
- GtkStylePropertiesPrivate *priv;
-
- priv = props->priv = G_TYPE_INSTANCE_GET_PRIVATE (props,
- GTK_TYPE_STYLE_PROPERTIES,
- GtkStylePropertiesPrivate);
-
- priv->properties = g_hash_table_new_full (NULL, NULL, NULL,
- (GDestroyNotify) property_data_free);
+ props->priv = gtk_style_properties_get_instance_private (props);
+ props->priv->properties = g_hash_table_new_full (NULL, NULL, NULL,
+ (GDestroyNotify) property_data_free);
}
static void
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
G_DEFINE_TYPE_WITH_CODE (GtkSwitch, gtk_switch, GTK_TYPE_WIDGET,
+ G_ADD_PRIVATE (GtkSwitch)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIONABLE,
gtk_switch_actionable_iface_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gpointer activatable_iface;
- g_type_class_add_private (klass, sizeof (GtkSwitchPrivate));
-
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
activatable_iface = g_type_default_interface_peek (GTK_TYPE_ACTIVATABLE);
G_GNUC_END_IGNORE_DEPRECATIONS;
static void
gtk_switch_init (GtkSwitch *self)
{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GTK_TYPE_SWITCH, GtkSwitchPrivate);
+ self->priv = gtk_switch_get_instance_private (self);
self->priv->use_action_appearance = TRUE;
gtk_widget_set_has_window (GTK_WIDGET (self), FALSE);
gtk_widget_set_can_focus (GTK_WIDGET (self), TRUE);
static void gtk_text_buffer_notify (GObject *object,
GParamSpec *pspec);
-G_DEFINE_TYPE (GtkTextBuffer, gtk_text_buffer, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkTextBuffer, gtk_text_buffer, G_TYPE_OBJECT)
static void
gtk_text_buffer_class_init (GtkTextBufferClass *klass)
G_TYPE_NONE,
1,
GTK_TYPE_CLIPBOARD);
-
- g_type_class_add_private (object_class, sizeof (GtkTextBufferPrivate));
}
static void
gtk_text_buffer_init (GtkTextBuffer *buffer)
{
- buffer->priv = G_TYPE_INSTANCE_GET_PRIVATE (buffer,
- GTK_TYPE_TEXT_BUFFER,
- GtkTextBufferPrivate);
-
+ buffer->priv = gtk_text_buffer_get_instance_private (buffer);
buffer->priv->clipboard_contents_buffers = NULL;
buffer->priv->tag_table = NULL;
guint mode : 2;
};
-G_DEFINE_TYPE (GtkTextHandle, _gtk_text_handle, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkTextHandle, _gtk_text_handle, G_TYPE_OBJECT)
static guint signals[LAST_SIGNAL] = { 0 };
P_("Window the coordinates are based upon"),
GDK_TYPE_WINDOW,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (object_class, sizeof (GtkTextHandlePrivate));
}
static void
GtkTextHandlePrivate *priv;
GtkWidgetPath *path;
- handle->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (handle,
- GTK_TYPE_TEXT_HANDLE,
- GtkTextHandlePrivate);
+ handle->priv = priv = _gtk_text_handle_get_instance_private (handle);
path = gtk_widget_path_new ();
gtk_widget_path_append_type (path, GTK_TYPE_TEXT_HANDLE);
#include <stdlib.h>
#include <string.h>
-#define GTK_TEXT_LAYOUT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_TEXT_LAYOUT, GtkTextLayoutPrivate))
+#define GTK_TEXT_LAYOUT_GET_PRIVATE(o) ((GtkTextLayoutPrivate *) gtk_text_layout_get_instance_private ((o)))
typedef struct _GtkTextLayoutPrivate GtkTextLayoutPrivate;
PangoAttrType gtk_text_attr_appearance_type = 0;
-G_DEFINE_TYPE (GtkTextLayout, gtk_text_layout, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkTextLayout, gtk_text_layout, G_TYPE_OBJECT)
static void
gtk_text_layout_dispose (GObject *object)
G_TYPE_OBJECT,
G_TYPE_INT,
G_TYPE_INT);
-
- g_type_class_add_private (object_class, sizeof (GtkTextLayoutPrivate));
}
static void
static guint signals[LAST_SIGNAL] = { 0 };
-G_DEFINE_TYPE (GtkTextTag, gtk_text_tag, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkTextTag, gtk_text_tag, G_TYPE_OBJECT)
static void
gtk_text_tag_class_init (GtkTextTagClass *klass)
G_TYPE_OBJECT,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE,
GTK_TYPE_TEXT_ITER);
-
- g_type_class_add_private (klass, sizeof (GtkTextTagPrivate));
}
static void
gtk_text_tag_init (GtkTextTag *text_tag)
{
- GtkTextTagPrivate *priv;
-
- text_tag->priv = G_TYPE_INSTANCE_GET_PRIVATE (text_tag,
- GTK_TYPE_TEXT_TAG,
- GtkTextTagPrivate);
- priv = text_tag->priv;
-
- priv->values = gtk_text_attributes_new ();
+ text_tag->priv = gtk_text_tag_get_instance_private (text_tag);
+ text_tag->priv->values = gtk_text_attributes_new ();
}
/**
static guint signals[LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE_WITH_CODE (GtkTextTagTable, gtk_text_tag_table, G_TYPE_OBJECT,
+ G_ADD_PRIVATE (GtkTextTagTable)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_text_tag_table_buildable_interface_init))
G_TYPE_NONE,
1,
GTK_TYPE_TEXT_TAG);
-
- g_type_class_add_private (klass, sizeof (GtkTextTagTablePrivate));
}
static void
gtk_text_tag_table_init (GtkTextTagTable *table)
{
- GtkTextTagTablePrivate *priv;
-
- table->priv = G_TYPE_INSTANCE_GET_PRIVATE (table,
- GTK_TYPE_TEXT_TAG_TABLE,
- GtkTextTagTablePrivate);
- priv = table->priv;
-
- priv->hash = g_hash_table_new (g_str_hash, g_str_equal);
+ table->priv = gtk_text_tag_table_get_instance_private (table);
+ table->priv->hash = g_hash_table_new (g_str_hash, g_str_equal);
}
/**
#define CURSOR_BLINK_TIME 1200
#define CURSOR_BLINK_TIMEOUT_SEC 10
-#define GTK_TEXT_VIEW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_TEXT_VIEW, GtkTextViewPrivate))
-
typedef struct _GtkTextWindow GtkTextWindow;
typedef struct _GtkTextPendingScroll GtkTextPendingScroll;
static gboolean test_touchscreen = FALSE;
G_DEFINE_TYPE_WITH_CODE (GtkTextView, gtk_text_view, GTK_TYPE_CONTAINER,
+ G_ADD_PRIVATE (GtkTextView)
G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
static void
"move-focus", 1,
GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_BACKWARD);
- g_type_class_add_private (gobject_class, sizeof (GtkTextViewPrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_TEXT_VIEW_ACCESSIBLE);
test_touchscreen = g_getenv ("GTK_TEST_TOUCHSCREEN") != NULL;
}
GtkTargetList *target_list;
GtkTextViewPrivate *priv;
- text_view->priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
+ text_view->priv = gtk_text_view_get_instance_private (text_view);
priv = text_view->priv;
gtk_widget_set_can_focus (widget, TRUE);
gchar *name;
};
-#define GTK_THEMING_ENGINE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_THEMING_ENGINE, GtkThemingEnginePrivate))
-
static void gtk_theming_engine_finalize (GObject *object);
static void gtk_theming_engine_impl_set_property (GObject *object,
guint prop_id,
gdouble x,
gdouble y);
-G_DEFINE_TYPE (GtkThemingEngine, gtk_theming_engine, G_TYPE_OBJECT)
-
+G_DEFINE_TYPE_WITH_PRIVATE (GtkThemingEngine, gtk_theming_engine, G_TYPE_OBJECT)
typedef struct GtkThemingModule GtkThemingModule;
typedef struct GtkThemingModuleClass GtkThemingModuleClass;
P_("Theming engine name"),
NULL,
G_PARAM_CONSTRUCT_ONLY | GTK_PARAM_READWRITE));
-
- g_type_class_add_private (object_class, sizeof (GtkThemingEnginePrivate));
}
static void
gtk_theming_engine_init (GtkThemingEngine *engine)
{
- engine->priv = GTK_THEMING_ENGINE_GET_PRIVATE (engine);
+ engine->priv = gtk_theming_engine_get_instance_private (engine);
}
static void
PROP_ACTIVE
};
-G_DEFINE_TYPE (GtkToggleAction, gtk_toggle_action, GTK_TYPE_ACTION)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkToggleAction, gtk_toggle_action, GTK_TYPE_ACTION)
static void gtk_toggle_action_activate (GtkAction *action);
static void set_property (GObject *object,
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
- g_type_class_add_private (gobject_class, sizeof (GtkToggleActionPrivate));
}
static void
gtk_toggle_action_init (GtkToggleAction *action)
{
- action->private_data = G_TYPE_INSTANCE_GET_PRIVATE (action,
- GTK_TYPE_TOGGLE_ACTION,
- GtkToggleActionPrivate);
+ action->private_data = gtk_toggle_action_get_instance_private (action);
action->private_data->active = FALSE;
action->private_data->draw_as_radio = FALSE;
}
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
G_DEFINE_TYPE_WITH_CODE (GtkToggleButton, gtk_toggle_button, GTK_TYPE_BUTTON,
+ G_ADD_PRIVATE (GtkToggleButton)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,
gtk_toggle_button_activatable_interface_init))
G_GNUC_END_IGNORE_DEPRECATIONS;
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
- g_type_class_add_private (class, sizeof (GtkToggleButtonPrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE);
}
static void
gtk_toggle_button_init (GtkToggleButton *toggle_button)
{
- GtkToggleButtonPrivate *priv;
-
- toggle_button->priv = G_TYPE_INSTANCE_GET_PRIVATE (toggle_button,
- GTK_TYPE_TOGGLE_BUTTON,
- GtkToggleButtonPrivate);
- priv = toggle_button->priv;
+ toggle_button->priv = gtk_toggle_button_get_instance_private (toggle_button);
+ toggle_button->priv->active = FALSE;
+ toggle_button->priv->draw_indicator = FALSE;
- priv->active = FALSE;
- priv->draw_indicator = FALSE;
GTK_BUTTON (toggle_button)->priv->depress_on_activate = TRUE;
}
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
G_DEFINE_TYPE_WITH_CODE (GtkToggleToolButton, gtk_toggle_tool_button, GTK_TYPE_TOOL_BUTTON,
+ G_ADD_PRIVATE (GtkToggleToolButton)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,
gtk_toggle_tool_button_activatable_interface_init))
G_GNUC_END_IGNORE_DEPRECATIONS;
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
- g_type_class_add_private (object_class, sizeof (GtkToggleToolButtonPrivate));
}
static void
GtkToolButton *tool_button = GTK_TOOL_BUTTON (button);
GtkToggleButton *toggle_button = GTK_TOGGLE_BUTTON (_gtk_tool_button_get_button (tool_button));
- button->priv = G_TYPE_INSTANCE_GET_PRIVATE (button,
- GTK_TYPE_TOGGLE_TOOL_BUTTON,
- GtkToggleToolButtonPrivate);
+ button->priv = gtk_toggle_tool_button_get_instance_private (button);
/* If the real button is a radio button, it may have been
* active at the time it was created.
G_DEFINE_TYPE_WITH_CODE (GtkToolbar, gtk_toolbar, GTK_TYPE_CONTAINER,
+ G_ADD_PRIVATE (GtkToolbar)
G_IMPLEMENT_INTERFACE (GTK_TYPE_TOOL_SHELL,
toolbar_tool_shell_iface_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE,
add_ctrl_tab_bindings (binding_set, 0, GTK_DIR_TAB_FORWARD);
add_ctrl_tab_bindings (binding_set, GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
-
- g_type_class_add_private (gobject_class, sizeof (GtkToolbarPrivate));
}
static void
GtkToolbarPrivate *priv;
GtkStyleContext *context;
- toolbar->priv = G_TYPE_INSTANCE_GET_PRIVATE (toolbar,
- GTK_TYPE_TOOLBAR,
- GtkToolbarPrivate);
+ toolbar->priv = gtk_toolbar_get_instance_private (toolbar);
priv = toolbar->priv;
gtk_widget_set_can_focus (GTK_WIDGET (toolbar), FALSE);
PROP_ACTION_TARGET
};
-static void gtk_tool_button_init (GtkToolButton *button,
- GtkToolButtonClass *klass);
-static void gtk_tool_button_class_init (GtkToolButtonClass *klass);
static void gtk_tool_button_set_property (GObject *object,
guint prop_id,
const GValue *value,
guint contents_invalid : 1;
};
-static GObjectClass *parent_class = NULL;
static GtkActivatableIface *parent_activatable_iface;
static guint toolbutton_signals[LAST_SIGNAL] = { 0 };
-GType
-gtk_tool_button_get_type (void)
-{
- static GType type = 0;
-
- if (!type)
- {
- const GInterfaceInfo actionable_info =
- {
- (GInterfaceInitFunc) gtk_tool_button_actionable_iface_init,
- (GInterfaceFinalizeFunc) NULL,
- NULL
- };
- const GInterfaceInfo activatable_info =
- {
- (GInterfaceInitFunc) gtk_tool_button_activatable_interface_init,
- (GInterfaceFinalizeFunc) NULL,
- NULL
- };
-
- type = g_type_register_static_simple (GTK_TYPE_TOOL_ITEM,
- I_("GtkToolButton"),
- sizeof (GtkToolButtonClass),
- (GClassInitFunc) gtk_tool_button_class_init,
- sizeof (GtkToolButton),
- (GInstanceInitFunc) gtk_tool_button_init,
- 0);
+/* for GTK_TYPE_ACTIVATABLE */
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS
- G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
- g_type_add_interface_static (type, GTK_TYPE_ACTIONABLE, &actionable_info);
- g_type_add_interface_static (type, GTK_TYPE_ACTIVATABLE,
- &activatable_info);
- G_GNUC_END_IGNORE_DEPRECATIONS;
- }
- return type;
-}
+G_DEFINE_TYPE_WITH_CODE (GtkToolButton, gtk_tool_button, GTK_TYPE_TOOL_ITEM,
+ G_ADD_PRIVATE (GtkToolButton)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIONABLE,
+ gtk_tool_button_actionable_iface_init)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,
+ gtk_tool_button_activatable_interface_init))
+
+G_GNUC_END_IGNORE_DEPRECATIONS
static void
gtk_tool_button_class_init (GtkToolButtonClass *klass)
GtkWidgetClass *widget_class;
GtkToolItemClass *tool_item_class;
- parent_class = g_type_class_peek_parent (klass);
-
object_class = (GObjectClass *)klass;
widget_class = (GtkWidgetClass *)klass;
tool_item_class = (GtkToolItemClass *)klass;
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
- g_type_class_add_private (object_class, sizeof (GtkToolButtonPrivate));
}
static void
-gtk_tool_button_init (GtkToolButton *button,
- GtkToolButtonClass *klass)
+gtk_tool_button_init (GtkToolButton *button)
{
GtkToolItem *toolitem = GTK_TOOL_ITEM (button);
- button->priv = G_TYPE_INSTANCE_GET_PRIVATE (button,
- GTK_TYPE_TOOL_BUTTON,
- GtkToolButtonPrivate);
+ button->priv = gtk_tool_button_get_instance_private (button);
button->priv->contents_invalid = TRUE;
gtk_tool_item_set_homogeneous (toolitem, TRUE);
/* create button */
- button->priv->button = g_object_new (klass->button_type, NULL);
+ button->priv->button = g_object_new (GTK_TOOL_BUTTON_GET_CLASS (button)->button_type, NULL);
gtk_button_set_focus_on_click (GTK_BUTTON (button->priv->button), FALSE);
g_signal_connect_object (button->priv->button, "clicked",
G_CALLBACK (button_clicked), button, 0);
strcmp ("is-important", pspec->name) == 0)
gtk_tool_button_construct_contents (GTK_TOOL_ITEM (object));
- if (parent_class->notify)
- parent_class->notify (object, pspec);
+ if (G_OBJECT_CLASS (gtk_tool_button_parent_class)->notify != NULL)
+ G_OBJECT_CLASS (gtk_tool_button_parent_class)->notify (object, pspec);
}
static void
if (button->priv->icon_widget)
g_object_unref (button->priv->icon_widget);
- parent_class->finalize (object);
+ G_OBJECT_CLASS (gtk_tool_button_parent_class)->finalize (object);
}
static GtkWidget *
static void
gtk_tool_button_style_updated (GtkWidget *widget)
{
- GTK_WIDGET_CLASS (parent_class)->style_updated (widget);
+ GTK_WIDGET_CLASS (gtk_tool_button_parent_class)->style_updated (widget);
gtk_tool_button_update_icon_spacing (GTK_TOOL_BUTTON (widget));
}
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
G_DEFINE_TYPE_WITH_CODE (GtkToolItem, gtk_tool_item, GTK_TYPE_BIN,
+ G_ADD_PRIVATE (GtkToolItem)
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,
gtk_tool_item_activatable_interface_init))
G_GNUC_END_IGNORE_DEPRECATIONS;
NULL, NULL,
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
- g_type_class_add_private (object_class, sizeof (GtkToolItemPrivate));
}
static void
{
gtk_widget_set_can_focus (GTK_WIDGET (toolitem), FALSE);
- toolitem->priv = G_TYPE_INSTANCE_GET_PRIVATE (toolitem,
- GTK_TYPE_TOOL_ITEM,
- GtkToolItemPrivate);
-
+ toolitem->priv = gtk_tool_item_get_instance_private (toolitem);
toolitem->priv->visible_horizontal = TRUE;
toolitem->priv->visible_vertical = TRUE;
toolitem->priv->homogeneous = FALSE;
toolitem->priv->expand = FALSE;
-
toolitem->priv->use_action_appearance = TRUE;
}
static void gtk_tool_item_group_tool_shell_init (GtkToolShellIface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkToolItemGroup, gtk_tool_item_group, GTK_TYPE_CONTAINER,
-G_IMPLEMENT_INTERFACE (GTK_TYPE_TOOL_SHELL, gtk_tool_item_group_tool_shell_init));
+ G_ADD_PRIVATE (GtkToolItemGroup)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_TOOL_SHELL,
+ gtk_tool_item_group_tool_shell_init));
static GtkWidget*
gtk_tool_item_group_get_alignment (GtkToolItemGroup *group)
gtk_widget_set_redraw_on_allocate (GTK_WIDGET (group), FALSE);
- group->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (group,
- GTK_TYPE_TOOL_ITEM_GROUP,
- GtkToolItemGroupPrivate);
+ group->priv = priv = gtk_tool_item_group_get_instance_private (group);
priv->children = NULL;
priv->header_spacing = DEFAULT_HEADER_SPACING;
G_MAXINT,
0,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (cls, sizeof (GtkToolItemGroupPrivate));
}
/**
G_DEFINE_TYPE_WITH_CODE (GtkToolPalette,
- gtk_tool_palette,
- GTK_TYPE_CONTAINER,
- G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL)
- G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
+ gtk_tool_palette,
+ GTK_TYPE_CONTAINER,
+ G_ADD_PRIVATE (GtkToolPalette)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
static void
gtk_tool_palette_init (GtkToolPalette *palette)
{
- palette->priv = G_TYPE_INSTANCE_GET_PRIVATE (palette,
- GTK_TYPE_TOOL_PALETTE,
- GtkToolPalettePrivate);
-
+ palette->priv = gtk_tool_palette_get_instance_private (palette);
palette->priv->groups = g_ptr_array_sized_new (4);
g_ptr_array_set_free_func (palette->priv->groups, g_free);
P_("Whether the item group should receive extra space when the palette grows"),
DEFAULT_CHILD_EXPAND,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (cls, sizeof (GtkToolPalettePrivate));
}
/**
gpointer user_data);
-G_DEFINE_TYPE (GtkTrayIcon, gtk_tray_icon, GTK_TYPE_PLUG)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkTrayIcon, gtk_tray_icon, GTK_TYPE_PLUG)
static void
gtk_tray_icon_class_init (GtkTrayIconClass *class)
G_MAXINT,
0,
GTK_PARAM_READABLE));
-
- g_type_class_add_private (class, sizeof (GtkTrayIconPrivate));
}
static void
gtk_tray_icon_init (GtkTrayIcon *icon)
{
- icon->priv = G_TYPE_INSTANCE_GET_PRIVATE (icon, GTK_TYPE_TRAY_ICON,
- GtkTrayIconPrivate);
-
+ icon->priv = gtk_tray_icon_get_instance_private (icon);
icon->priv->stamp = 1;
icon->priv->orientation = GTK_ORIENTATION_HORIZONTAL;
icon->priv->fg_color.red = 0.0;
static GQuark tree_menu_path_quark = 0;
G_DEFINE_TYPE_WITH_CODE (GtkTreeMenu, _gtk_tree_menu, GTK_TYPE_MENU,
+ G_ADD_PRIVATE (GtkTreeMenu)
G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
gtk_tree_menu_cell_layout_init));
static void
_gtk_tree_menu_init (GtkTreeMenu *menu)
{
- GtkTreeMenuPrivate *priv;
-
- menu->priv = G_TYPE_INSTANCE_GET_PRIVATE (menu,
- GTK_TYPE_TREE_MENU,
- GtkTreeMenuPrivate);
- priv = menu->priv;
-
- priv->model = NULL;
- priv->root = NULL;
- priv->area = NULL;
- priv->context = NULL;
-
- priv->size_changed_id = 0;
- priv->row_inserted_id = 0;
- priv->row_deleted_id = 0;
- priv->row_reordered_id = 0;
- priv->row_changed_id = 0;
-
- priv->wrap_width = 0;
- priv->row_span_col = -1;
- priv->col_span_col = -1;
-
- priv->menu_with_header = FALSE;
- priv->tearoff = FALSE;
-
- priv->row_separator_func = NULL;
- priv->row_separator_data = NULL;
- priv->row_separator_destroy = NULL;
-
- priv->header_func = NULL;
- priv->header_data = NULL;
- priv->header_destroy = NULL;
+ menu->priv = _gtk_tree_menu_get_instance_private (menu);
+ menu->priv->row_span_col = -1;
+ menu->priv->col_span_col = -1;
gtk_menu_set_reserve_toggle_size (GTK_MENU (menu), FALSE);
}
G_MAXINT,
-1,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (object_class, sizeof (GtkTreeMenuPrivate));
}
/****************************************************************
G_DEFINE_TYPE_WITH_CODE (GtkTreeModelFilter, gtk_tree_model_filter, G_TYPE_OBJECT,
+ G_ADD_PRIVATE (GtkTreeModelFilter)
G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
gtk_tree_model_filter_tree_model_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE,
static void
gtk_tree_model_filter_init (GtkTreeModelFilter *filter)
{
- filter->priv = G_TYPE_INSTANCE_GET_PRIVATE (filter,
- GTK_TYPE_TREE_MODEL_FILTER,
- GtkTreeModelFilterPrivate);
-
+ filter->priv = gtk_tree_model_filter_get_instance_private (filter);
filter->priv->visible_column = -1;
filter->priv->zero_ref_count = 0;
filter->priv->visible_method_set = FALSE;
("The virtual root (relative to the child model) for this filtermodel"),
GTK_TYPE_TREE_PATH,
GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
-
- g_type_class_add_private (object_class, sizeof (GtkTreeModelFilterPrivate));
}
static void
G_DEFINE_TYPE_WITH_CODE (GtkTreeModelSort, gtk_tree_model_sort, G_TYPE_OBJECT,
+ G_ADD_PRIVATE (GtkTreeModelSort)
G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
gtk_tree_model_sort_tree_model_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_SORTABLE,
{
GtkTreeModelSortPrivate *priv;
- priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_model_sort,
- GTK_TYPE_TREE_MODEL_SORT,
- GtkTreeModelSortPrivate);
- tree_model_sort->priv = priv;
+ tree_model_sort->priv = priv =
+ gtk_tree_model_sort_get_instance_private (tree_model_sort);
priv->sort_column_id = GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID;
priv->stamp = 0;
priv->zero_ref_count = 0;
P_("The model for the TreeModelSort to sort"),
GTK_TYPE_TREE_MODEL,
GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
-
- g_type_class_add_private (class, sizeof (GtkTreeModelSortPrivate));
}
static void
static GParamSpec *properties[N_PROPERTIES];
static guint tree_selection_signals [LAST_SIGNAL] = { 0 };
-G_DEFINE_TYPE (GtkTreeSelection, gtk_tree_selection, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkTreeSelection, gtk_tree_selection, G_TYPE_OBJECT)
static void
gtk_tree_selection_class_init (GtkTreeSelectionClass *class)
NULL, NULL,
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
- g_type_class_add_private (class, sizeof (GtkTreeSelectionPrivate));
}
static void
gtk_tree_selection_init (GtkTreeSelection *selection)
{
- GtkTreeSelectionPrivate *priv;
-
- selection->priv = G_TYPE_INSTANCE_GET_PRIVATE (selection,
- GTK_TYPE_TREE_SELECTION,
- GtkTreeSelectionPrivate);
- priv = selection->priv;
-
- priv->type = GTK_SELECTION_SINGLE;
+ selection->priv = gtk_tree_selection_get_instance_private (selection);
+ selection->priv->type = GTK_SELECTION_SINGLE;
}
static void
}
G_DEFINE_TYPE_WITH_CODE (GtkTreeStore, gtk_tree_store, G_TYPE_OBJECT,
+ G_ADD_PRIVATE (GtkTreeStore)
G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
gtk_tree_store_tree_model_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE,
object_class = (GObjectClass *) class;
object_class->finalize = gtk_tree_store_finalize;
-
- g_type_class_add_private (class, sizeof (GtkTreeStorePrivate));
}
static void
{
GtkTreeStorePrivate *priv;
- priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_store,
- GTK_TYPE_TREE_STORE,
- GtkTreeStorePrivate);
+ priv = gtk_tree_store_get_instance_private (tree_store);
tree_store->priv = priv;
priv->root = g_node_new (NULL);
/* While the odds are against us getting 0... */
*/
G_DEFINE_TYPE_WITH_CODE (GtkTreeView, gtk_tree_view, GTK_TYPE_CONTAINER,
+ G_ADD_PRIVATE (GtkTreeView)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_tree_view_buildable_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
gtk_binding_entry_add_signal (binding_set, GDK_KEY_F, GDK_CONTROL_MASK, "start-interactive-search", 0);
- g_type_class_add_private (o_class, sizeof (GtkTreeViewPrivate));
-
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_TREE_VIEW_ACCESSIBLE);
}
static void
gtk_tree_view_init (GtkTreeView *tree_view)
{
- tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view, GTK_TYPE_TREE_VIEW, GtkTreeViewPrivate);
+ tree_view->priv = gtk_tree_view_get_instance_private (tree_view);
gtk_widget_set_can_focus (GTK_WIDGET (tree_view), TRUE);
gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE);
static guint tree_column_signals[LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE_WITH_CODE (GtkTreeViewColumn, gtk_tree_view_column, G_TYPE_INITIALLY_UNOWNED,
+ G_ADD_PRIVATE (GtkTreeViewColumn)
G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
gtk_tree_view_column_cell_layout_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
P_("The GtkCellArea used to layout cells"),
GTK_TYPE_CELL_AREA,
GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
-
- g_type_class_add_private (class, sizeof (GtkTreeViewColumnPrivate));
}
static void
{
GtkTreeViewColumnPrivate *priv;
- tree_column->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_column,
- GTK_TYPE_TREE_VIEW_COLUMN,
- GtkTreeViewColumnPrivate);
+ tree_column->priv = gtk_tree_view_column_get_instance_private (tree_column);
priv = tree_column->priv;
priv->button = NULL;
static guint ui_manager_signals[LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE_WITH_CODE (GtkUIManager, gtk_ui_manager, G_TYPE_OBJECT,
+ G_ADD_PRIVATE (GtkUIManager)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_ui_manager_buildable_init))
klass->disconnect_proxy = NULL;
klass->pre_activate = NULL;
klass->post_activate = NULL;
-
- g_type_class_add_private (gobject_class, sizeof (GtkUIManagerPrivate));
}
-
static void
gtk_ui_manager_init (GtkUIManager *manager)
{
guint merge_id;
GNode *node;
- manager->private_data = G_TYPE_INSTANCE_GET_PRIVATE (manager,
- GTK_TYPE_UI_MANAGER,
- GtkUIManagerPrivate);
+ manager->private_data = gtk_ui_manager_get_instance_private (manager);
manager->private_data->accel_group = gtk_accel_group_new ();
const cairo_region_t *region);
G_DEFINE_TYPE_WITH_CODE (GtkViewport, gtk_viewport, GTK_TYPE_BIN,
+ G_ADD_PRIVATE (GtkViewport)
G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
static void
GTK_TYPE_SHADOW_TYPE,
GTK_SHADOW_IN,
GTK_PARAM_READWRITE));
-
- g_type_class_add_private (class, sizeof (GtkViewportPrivate));
}
static void
{
GtkViewportPrivate *priv;
- viewport->priv = G_TYPE_INSTANCE_GET_PRIVATE (viewport,
- GTK_TYPE_VIEWPORT,
- GtkViewportPrivate);
+ viewport->priv = gtk_viewport_get_instance_private (viewport);
priv = viewport->priv;
gtk_widget_set_has_window (GTK_WIDGET (viewport), TRUE);
GdkEventExpose *event);
/* --- variables --- */
+static gint GtkWidget_private_offset = 0;
static gpointer gtk_widget_parent_class = NULL;
static guint widget_signals[LAST_SIGNAL] = { 0 };
static guint composite_child_stack = 0;
g_type_add_class_private (widget_type, sizeof (GtkWidgetClassPrivate));
+ GtkWidget_private_offset =
+ g_type_add_instance_private (widget_type, sizeof (GtkWidgetPrivate));
+
g_type_add_interface_static (widget_type, ATK_TYPE_IMPLEMENTOR,
&accessibility_info) ;
g_type_add_interface_static (widget_type, GTK_TYPE_BUILDABLE,
return widget_type;
}
+static inline gpointer
+gtk_widget_get_instance_private (GtkWidget *self)
+{
+ return (G_STRUCT_MEMBER_P (self, GtkWidget_private_offset));
+}
+
static void
gtk_widget_base_class_init (gpointer g_class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GtkBindingSet *binding_set;
+ g_type_class_adjust_private_offset (klass, &GtkWidget_private_offset);
gtk_widget_parent_class = g_type_class_peek_parent (klass);
quark_property_parser = g_quark_from_static_string ("gtk-rc-property-parser");
1, G_MAXINT, 20,
GTK_PARAM_READABLE));
- g_type_class_add_private (klass, sizeof (GtkWidgetPrivate));
-
gtk_widget_class_set_accessible_type (klass, GTK_TYPE_WIDGET_ACCESSIBLE);
}
{
GtkWidgetPrivate *priv;
- widget->priv = G_TYPE_INSTANCE_GET_PRIVATE (widget,
- GTK_TYPE_WIDGET,
- GtkWidgetPrivate);
+ widget->priv = gtk_widget_get_instance_private (widget);
priv = widget->priv;
priv->child_visible = TRUE;
static void unset_titlebar (GtkWindow *window);
G_DEFINE_TYPE_WITH_CODE (GtkWindow, gtk_window, GTK_TYPE_BIN,
+ G_ADD_PRIVATE (GtkWindow)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_window_buildable_interface_init))
klass->activate_focus = gtk_window_real_activate_focus;
klass->keys_changed = gtk_window_keys_changed;
- g_type_class_add_private (gobject_class, sizeof (GtkWindowPrivate));
-
/* Construct */
g_object_class_install_property (gobject_class,
PROP_TYPE,
widget = GTK_WIDGET (window);
- window->priv = G_TYPE_INSTANCE_GET_PRIVATE (window,
- GTK_TYPE_WINDOW,
- GtkWindowPrivate);
+ window->priv = gtk_window_get_instance_private (window);
priv = window->priv;
gtk_widget_set_has_window (widget, TRUE);
* freed.
*/
-G_DEFINE_TYPE (GtkWindowGroup, gtk_window_group, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_PRIVATE (GtkWindowGroup, gtk_window_group, G_TYPE_OBJECT)
static void
gtk_window_group_init (GtkWindowGroup *group)
{
- group->priv = G_TYPE_INSTANCE_GET_PRIVATE (group,
- GTK_TYPE_WINDOW_GROUP,
- GtkWindowGroupPrivate);
+ group->priv = gtk_window_group_get_instance_private (group);
}
static void
gtk_window_group_class_init (GtkWindowGroupClass *klass)
{
- g_type_class_add_private (klass, sizeof (GtkWindowGroupPrivate));
}
/**
projects / gtk4.git / commitdiff